commit c8564e46538b03e237c507d40df16834a37c2b69
author Dart CI <dart-internal-merge@dart-ci-internal.iam.gserviceaccount.com> Thu Feb 09 07:47:38 2023 -0800
committer Dart CI <dart-internal-merge@dart-ci-internal.iam.gserviceaccount.com> Thu Feb 09 07:47:38 2023 -0800
tree 5b79dc7c72f231cc69802800ee7843f340c9aefb
parent 69e86acbce3a086fe4a69bb570cd1aed4545737e
parent d89ae3c2c6bacedb385c1c2f40bcfb6aa178663b

Version 3.0.0-221.0.dev

Merge d89ae3c2c6bacedb385c1c2f40bcfb6aa178663b into dev

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

diff --git a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
index 84d327c..a6943bf 100644
--- a/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart
@@ -6926,6 +6926,81 @@
         r"""The escape sequence starting with '\u' isn't a valid code point.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeInvalidConstantPatternDuplicateConst =
+    messageInvalidConstantPatternDuplicateConst;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageInvalidConstantPatternDuplicateConst =
+    const MessageCode("InvalidConstantPatternDuplicateConst",
+        index: 137,
+        problemMessage:
+            r"""Duplicate 'const' keyword in constant expression.""",
+        correctionMessage: r"""Try removing one of the 'const' keywords.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeInvalidConstantPatternEmptyRecordLiteral =
+    messageInvalidConstantPatternEmptyRecordLiteral;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageInvalidConstantPatternEmptyRecordLiteral =
+    const MessageCode("InvalidConstantPatternEmptyRecordLiteral",
+        index: 138,
+        problemMessage:
+            r"""The empty record literal is not supported as a constant pattern.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeInvalidConstantPatternGeneric =
+    messageInvalidConstantPatternGeneric;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageInvalidConstantPatternGeneric = const MessageCode(
+    "InvalidConstantPatternGeneric",
+    index: 139,
+    problemMessage:
+        r"""This expression is not supported as a constant pattern.""",
+    correctionMessage: r"""Try wrapping the expression in 'const ( ... )'.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Null> codeInvalidConstantPatternNegation =
+    messageInvalidConstantPatternNegation;
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const MessageCode messageInvalidConstantPatternNegation = const MessageCode(
+    "InvalidConstantPatternNegation",
+    index: 135,
+    problemMessage:
+        r"""Only negation of a numeric literal is supported as a constant pattern.""",
+    correctionMessage: r"""Try wrapping the expression in 'const ( ... )'.""");
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateInvalidConstantPatternUnary = const Template<
+        Message Function(String name)>(
+    problemMessageTemplate:
+        r"""The unary operator #name is not supported as a constant pattern.""",
+    correctionMessageTemplate:
+        r"""Try wrapping the expression in 'const ( ... )'.""",
+    withArguments: _withArgumentsInvalidConstantPatternUnary);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)> codeInvalidConstantPatternUnary =
+    const Code<Message Function(String name)>("InvalidConstantPatternUnary",
+        index: 136);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsInvalidConstantPatternUnary(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeInvalidConstantPatternUnary,
+      problemMessage:
+          """The unary operator ${name} is not supported as a constant pattern.""",
+      correctionMessage: """Try wrapping the expression in 'const ( ... )'.""",
+      arguments: {'name': name});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(String name)> templateInvalidContinueTarget =
     const Template<Message Function(String name)>(
         problemMessageTemplate: r"""Can't continue at '#name'.""",
@@ -12867,14 +12942,6 @@
     correctionMessage: r"""Try removing the type arguments.""");
 
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const Code<Null> codeWasmSyncStar = messageWasmSyncStar;
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
-const MessageCode messageWasmSyncStar = const MessageCode("WasmSyncStar",
-    severity: Severity.warning,
-    problemMessage: r"""Compilation to Wasm does not support 'sync*'.""");
-
-// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeWeakWithStrongDillLibrary =
     messageWeakWithStrongDillLibrary;
 

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

diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/parser.dart b/pkg/_fe_analyzer_shared/lib/src/parser/parser.dart
index 72c8899..3ed93de 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/parser.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser.dart
@@ -35,7 +35,7 @@
 
 export 'member_kind.dart' show MemberKind;
 
-export 'parser_impl.dart' show Parser;
+export 'parser_impl.dart' show ConstantPatternContext, Parser;
 
 export 'parser_error.dart' show ParserError;
 

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

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 0161b8c..7ca1b52 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart
@@ -5564,8 +5564,8 @@
       } else {
         token = optional('throw', token.next!)
             ? parseThrowExpression(token, /* allowCascades = */ true)
-            : parsePrecedenceExpression(
-                token, ASSIGNMENT_PRECEDENCE, /* allowCascades = */ true);
+            : parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE,
+                /* allowCascades = */ true, ConstantPatternContext.none);
       }
     }
     expressionDepth--;
@@ -5575,8 +5575,8 @@
   Token parseExpressionWithoutCascade(Token token) {
     return optional('throw', token.next!)
         ? parseThrowExpression(token, /* allowCascades = */ false)
-        : parsePrecedenceExpression(
-            token, ASSIGNMENT_PRECEDENCE, /* allowCascades = */ false);
+        : parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE,
+            /* allowCascades = */ false, ConstantPatternContext.none);
   }
 
   bool canParseAsConditional(Token question) {
@@ -5620,34 +5620,44 @@
     return token;
   }
 
-  Token parsePrecedenceExpression(
-      Token token, int precedence, bool allowCascades) {
+  Token parsePrecedenceExpression(Token token, int precedence,
+      bool allowCascades, ConstantPatternContext constantPatternContext) {
     assert(precedence >= 1);
     assert(precedence <= SELECTOR_PRECEDENCE);
-    token = parseUnaryExpression(token, allowCascades);
+    token = parseUnaryExpression(token, allowCascades, constantPatternContext);
     Token bangToken = token;
     if (optional('!', token.next!)) {
       bangToken = token.next!;
     }
     TypeParamOrArgInfo typeArg = computeMethodTypeArguments(bangToken);
     if (typeArg != noTypeParamOrArg) {
-      // For example a(b)<T>(c), where token is before '<'.
       if (optional('!', bangToken)) {
+        // For example `e!<int>()`, where [token] is before '<'.
         listener.handleNonNullAssertExpression(bangToken);
       }
       token = typeArg.parseArguments(bangToken, this);
       if (!optional('(', token.next!)) {
+        // For example `e<a, b>;`, where [token] is before ';' or
+        // `C<int>.new`, where [token] is before '.'.
+        if (constantPatternContext != ConstantPatternContext.none) {
+          reportRecoverableError(
+              bangToken.next!, codes.messageInvalidConstantPatternGeneric);
+        }
         listener.handleTypeArgumentApplication(bangToken.next!);
         typeArg = noTypeParamOrArg;
       }
     }
 
     return _parsePrecedenceExpressionLoop(
-        precedence, allowCascades, typeArg, token);
+        precedence, allowCascades, typeArg, token, constantPatternContext);
   }
 
-  Token _parsePrecedenceExpressionLoop(int precedence, bool allowCascades,
-      TypeParamOrArgInfo typeArg, Token token) {
+  Token _parsePrecedenceExpressionLoop(
+      int precedence,
+      bool allowCascades,
+      TypeParamOrArgInfo typeArg,
+      Token token,
+      ConstantPatternContext constantPatternContext) {
     Token next = token.next!;
     TokenType type = next.type;
     int tokenLevel = _computePrecedence(next, forPattern: false);
@@ -5683,7 +5693,8 @@
           }
           token = optional('throw', next.next!)
               ? parseThrowExpression(next, /* allowCascades = */ false)
-              : parsePrecedenceExpression(next, level, allowCascades);
+              : parsePrecedenceExpression(
+                  next, level, allowCascades, ConstantPatternContext.none);
           listener.handleAssignmentExpression(operator);
         } else if (identical(tokenLevel, POSTFIX_PRECEDENCE)) {
           if ((identical(type, TokenType.PLUS_PLUS)) ||
@@ -5703,7 +5714,9 @@
             // unary expression isn't legal after a period, so we call
             // [parsePrimary] instead.
             token = parsePrimary(
-                token.next!, IdentifierContext.expressionContinuation);
+                token.next!,
+                IdentifierContext.expressionContinuation,
+                ConstantPatternContext.none);
             listener.handleEndingBinaryExpression(operator);
 
             Token bangToken = token;
@@ -5718,6 +5731,10 @@
               }
               token = typeArg.parseArguments(bangToken, this);
               if (!optional('(', token.next!)) {
+                if (constantPatternContext != ConstantPatternContext.none) {
+                  reportRecoverableError(bangToken.next!,
+                      codes.messageInvalidConstantPatternGeneric);
+                }
                 listener.handleTypeArgumentApplication(bangToken.next!);
                 typeArg = noTypeParamOrArg;
               }
@@ -5777,8 +5794,8 @@
           listener.beginBinaryExpression(next);
           // Left associative, so we recurse at the next higher
           // precedence level.
-          token =
-              parsePrecedenceExpression(token.next!, level + 1, allowCascades);
+          token = parsePrecedenceExpression(token.next!, level + 1,
+              allowCascades, ConstantPatternContext.none);
           listener.endBinaryExpression(operator);
         }
         next = token.next!;
@@ -5802,8 +5819,8 @@
       // Attempt recovery
       if (_attemptPrecedenceLevelRecovery(
           token, precedence, /* currentLevel = */ -1, allowCascades, typeArg)) {
-        return _parsePrecedenceExpressionLoop(
-            precedence, allowCascades, typeArg, token);
+        return _parsePrecedenceExpressionLoop(precedence, allowCascades,
+            typeArg, token, ConstantPatternContext.none);
       }
     }
     return token;
@@ -5847,8 +5864,8 @@
       cachedRewriter = undoableTokenStreamRewriter;
       rewriter.replaceNextTokenWithSyntheticToken(token, replacement);
       bool acceptRecovery = false;
-      Token afterExpression = _parsePrecedenceExpressionLoop(
-          precedence, allowCascades, typeArg, token);
+      Token afterExpression = _parsePrecedenceExpressionLoop(precedence,
+          allowCascades, typeArg, token, ConstantPatternContext.none);
       Token afterExpressionNext = afterExpression.next!;
 
       if (!nullListener.hasErrors &&
@@ -6013,14 +6030,16 @@
     return token;
   }
 
-  Token parseUnaryExpression(Token token, bool allowCascades) {
+  Token parseUnaryExpression(Token token, bool allowCascades,
+      ConstantPatternContext constantPatternContext) {
     String? value = token.next!.stringValue;
     // Prefix:
     if (identical(value, 'await')) {
       if (inPlainSync) {
         if (!looksLikeAwaitExpression(
             token, AwaitOrYieldContext.UnaryExpression)) {
-          return parsePrimary(token, IdentifierContext.expression);
+          return parsePrimary(
+              token, IdentifierContext.expression, ConstantPatternContext.none);
         }
         // Recovery: Looks like an expression preceded by `await`.
         // Fall through and let parseAwaitExpression report the error.
@@ -6034,15 +6053,31 @@
           codes.messageUnsupportedPrefixPlus,
           new SyntheticStringToken(
               TokenType.IDENTIFIER, '', token.next!.offset));
-      return parsePrimary(token, IdentifierContext.expression);
-    } else if ((identical(value, '!')) ||
-        (identical(value, '-')) ||
-        (identical(value, '~'))) {
+      return parsePrimary(
+          token, IdentifierContext.expression, constantPatternContext);
+    } else if ((identical(value, '!')) || (identical(value, '~'))) {
+      Token operator = token.next!;
+      if (constantPatternContext != ConstantPatternContext.none) {
+        reportRecoverableError(operator,
+            codes.templateInvalidConstantPatternUnary.withArguments(value!));
+      }
+      // Right associative, so we recurse at the same precedence
+      // level.
+      token = parsePrecedenceExpression(operator, POSTFIX_PRECEDENCE,
+          allowCascades, ConstantPatternContext.none);
+      listener.handleUnaryPrefixExpression(operator);
+      return token;
+    } else if (identical(value, '-')) {
       Token operator = token.next!;
       // Right associative, so we recurse at the same precedence
       // level.
       token = parsePrecedenceExpression(
-          token.next!, POSTFIX_PRECEDENCE, allowCascades);
+          operator,
+          POSTFIX_PRECEDENCE,
+          allowCascades,
+          constantPatternContext != ConstantPatternContext.none
+              ? ConstantPatternContext.numericLiteralOnly
+              : ConstantPatternContext.none);
       listener.handleUnaryPrefixExpression(operator);
       return token;
     } else if ((identical(value, '++')) || identical(value, '--')) {
@@ -6050,8 +6085,8 @@
       Token operator = token.next!;
       // Right associative, so we recurse at the same precedence
       // level.
-      token = parsePrecedenceExpression(
-          token.next!, POSTFIX_PRECEDENCE, allowCascades);
+      token = parsePrecedenceExpression(operator, POSTFIX_PRECEDENCE,
+          allowCascades, ConstantPatternContext.none);
       listener.handleUnaryPrefixAssignmentExpression(operator);
       return token;
     } else if (useImplicitCreationExpression && token.next!.isIdentifier) {
@@ -6078,7 +6113,8 @@
         }
       }
     }
-    return parsePrimary(token, IdentifierContext.expression);
+    return parsePrimary(
+        token, IdentifierContext.expression, constantPatternContext);
   }
 
   Token parseArgumentOrIndexStar(
@@ -6174,24 +6210,48 @@
     return token;
   }
 
-  Token parsePrimary(Token token, IdentifierContext context) {
+  Token parsePrimary(Token token, IdentifierContext context,
+      ConstantPatternContext constantPatternContext) {
     _tryRewriteNewToIdentifier(token, context);
-    final int kind = token.next!.kind;
+    final Token next = token.next!;
+    final int kind = next.kind;
     if (kind == IDENTIFIER_TOKEN) {
+      if (constantPatternContext == ConstantPatternContext.numericLiteralOnly) {
+        reportRecoverableError(
+            next, codes.messageInvalidConstantPatternNegation);
+      }
       return parseSendOrFunctionLiteral(token, context);
     } else if (kind == INT_TOKEN || kind == HEXADECIMAL_TOKEN) {
       return parseLiteralInt(token);
     } else if (kind == DOUBLE_TOKEN) {
       return parseLiteralDouble(token);
     } else if (kind == STRING_TOKEN) {
+      if (constantPatternContext == ConstantPatternContext.numericLiteralOnly) {
+        reportRecoverableError(
+            next, codes.messageInvalidConstantPatternNegation);
+      }
       return parseLiteralString(token);
     } else if (kind == HASH_TOKEN) {
+      if (constantPatternContext == ConstantPatternContext.numericLiteralOnly) {
+        reportRecoverableError(
+            next, codes.messageInvalidConstantPatternNegation);
+      }
       return parseLiteralSymbol(token);
     } else if (kind == KEYWORD_TOKEN) {
-      final String? value = token.next!.stringValue;
+      final String? value = next.stringValue;
       if (identical(value, "true") || identical(value, "false")) {
+        if (constantPatternContext ==
+            ConstantPatternContext.numericLiteralOnly) {
+          reportRecoverableError(
+              next, codes.messageInvalidConstantPatternNegation);
+        }
         return parseLiteralBool(token);
       } else if (identical(value, "null")) {
+        if (constantPatternContext ==
+            ConstantPatternContext.numericLiteralOnly) {
+          reportRecoverableError(
+              next, codes.messageInvalidConstantPatternNegation);
+        }
         return parseLiteralNull(token);
       } else if (identical(value, "this")) {
         return parseThisExpression(token, context);
@@ -6203,6 +6263,10 @@
       } else if (identical(value, "new")) {
         return parseNewExpression(token);
       } else if (identical(value, "const")) {
+        if (constantPatternContext == ConstantPatternContext.explicit) {
+          reportRecoverableError(
+              next, codes.messageInvalidConstantPatternDuplicateConst);
+        }
         return parseConstExpression(token);
       } else if (identical(value, "void")) {
         return parseSendOrFunctionLiteral(token, context);
@@ -6213,18 +6277,24 @@
         return parseAssert(token, Assert.Expression);
       } else if (allowPatterns && identical(value, "switch")) {
         return parseSwitchExpression(token);
-      } else if (token.next!.isIdentifier) {
+      } else if (next.isIdentifier) {
+        if (constantPatternContext ==
+            ConstantPatternContext.numericLiteralOnly) {
+          reportRecoverableError(
+              next, codes.messageInvalidConstantPatternNegation);
+        }
         return parseSendOrFunctionLiteral(token, context);
       } else if (identical(value, "return")) {
         // Recovery
         token = token.next!;
         reportRecoverableErrorWithToken(token, codes.templateUnexpectedToken);
-        return parsePrimary(token, context);
+        return parsePrimary(token, context, ConstantPatternContext.none);
       } else {
         // Fall through to the recovery code.
       }
     } else if (kind == OPEN_PAREN_TOKEN) {
-      return parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(token);
+      return parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(
+          token, constantPatternContext);
     } else if (kind == OPEN_SQUARE_BRACKET_TOKEN ||
         optional('[]', token.next!)) {
       listener.handleNoTypeArguments(token.next!);
@@ -6244,7 +6314,7 @@
   }
 
   Token parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(
-      Token token) {
+      Token token, ConstantPatternContext constantPatternContext) {
     Token next = token.next!;
     assert(optional('(', next));
 
@@ -6276,7 +6346,7 @@
     bool old = mayParseFunctionExpressions;
     mayParseFunctionExpressions = true;
     token = parseParenthesizedExpressionOrRecordLiteral(
-        token, /* constKeywordForRecord = */ null);
+        token, /* constKeywordForRecord = */ null, constantPatternContext);
     mayParseFunctionExpressions = old;
     return token;
   }
@@ -6304,7 +6374,9 @@
   /// If [constKeywordForRecord] is non-null it is forced to be a record
   /// literal and an error will be issued if there is no trailing comma.
   Token parseParenthesizedExpressionOrRecordLiteral(
-      Token token, Token? constKeywordForRecord) {
+      Token token,
+      Token? constKeywordForRecord,
+      ConstantPatternContext constantPatternContext) {
     Token begin = token.next!;
     assert(optional('(', begin));
     listener.beginParenthesizedExpressionOrRecordLiteral(begin);
@@ -6370,6 +6442,9 @@
       } else if (count == 1 && !wasValidRecord) {
         reportRecoverableError(
             token, codes.messageRecordLiteralOnePositionalFieldNoTrailingComma);
+      } else if (constantPatternContext != ConstantPatternContext.none) {
+        reportRecoverableError(
+            token, codes.messageInvalidConstantPatternEmptyRecordLiteral);
       }
       listener.endRecordLiteral(begin, count, constKeywordForRecord);
     } else {
@@ -6797,7 +6872,8 @@
               identifier,
               codes.templateLiteralWithClassAndNew
                   .withArguments(value.toLowerCase(), identifier));
-          return parsePrimary(identifier, IdentifierContext.expression);
+          return parsePrimary(identifier, IdentifierContext.expression,
+              ConstantPatternContext.none);
         }
       } else if (value == "List" && !optional('.', identifier.next!)) {
         potentialTypeArg = computeTypeParamOrArg(identifier);
@@ -6810,7 +6886,8 @@
               identifier,
               codes.templateLiteralWithClassAndNew
                   .withArguments(value.toLowerCase(), identifier));
-          return parsePrimary(identifier, IdentifierContext.expression);
+          return parsePrimary(identifier, IdentifierContext.expression,
+              ConstantPatternContext.none);
         }
       }
     } else {
@@ -6828,12 +6905,14 @@
             optional('[]', afterToken)) {
           // Recover by ignoring the `new` and parse as a literal map/set/list.
           reportRecoverableError(newKeyword, codes.messageLiteralWithNew);
-          return parsePrimary(newKeyword, IdentifierContext.expression);
+          return parsePrimary(newKeyword, IdentifierContext.expression,
+              ConstantPatternContext.none);
         }
       } else if (value == "{" || value == "[" || value == "[]") {
         // Recover by ignoring the `new` and parse as a literal map/set/list.
         reportRecoverableError(newKeyword, codes.messageLiteralWithNew);
-        return parsePrimary(newKeyword, IdentifierContext.expression);
+        return parsePrimary(newKeyword, IdentifierContext.expression,
+            ConstantPatternContext.none);
       }
     }
 
@@ -6888,7 +6967,8 @@
     if (identical(value, '(')) {
       // Const record literal.
       listener.beginConstLiteral(next);
-      token = parseParenthesizedExpressionOrRecordLiteral(token, constKeyword);
+      token = parseParenthesizedExpressionOrRecordLiteral(
+          token, constKeyword, ConstantPatternContext.none);
       listener.endConstLiteral(token.next!);
       return token;
     }
@@ -7148,7 +7228,7 @@
               identifier,
               codes.templateLiteralWithClass
                   .withArguments(value.toLowerCase(), identifier));
-          return parsePrimary(identifier, context);
+          return parsePrimary(identifier, context, ConstantPatternContext.none);
         }
       } else if (value == "List") {
         potentialTypeArg = computeTypeParamOrArg(identifier);
@@ -7164,7 +7244,7 @@
               identifier,
               codes.templateLiteralWithClass
                   .withArguments(value.toLowerCase(), identifier));
-          return parsePrimary(identifier, context);
+          return parsePrimary(identifier, context, ConstantPatternContext.none);
         }
       }
     }
@@ -8233,8 +8313,8 @@
     Token awaitToken = token.next!;
     assert(optional('await', awaitToken));
     listener.beginAwaitExpression(awaitToken);
-    token = parsePrecedenceExpression(
-        awaitToken, POSTFIX_PRECEDENCE, allowCascades);
+    token = parsePrecedenceExpression(awaitToken, POSTFIX_PRECEDENCE,
+        allowCascades, ConstantPatternContext.none);
     if (inAsync) {
       listener.endAwaitExpression(awaitToken, token.next!);
     } else {
@@ -9516,7 +9596,7 @@
       case 'const':
         // constantPattern ::= booleanLiteral
         //                   | nullLiteral
-        //                   | numericLiteral
+        //                   | '-'? numericLiteral
         //                   | stringLiteral
         //                   | identifier
         //                   | qualifiedName
@@ -9525,13 +9605,9 @@
         //                   | 'const' typeArguments? '{' elements? '}'
         //                   | 'const' '(' expression ')'
         Token const_ = next;
-        // TODO(paulberry): report error if this constant is not permitted by
-        // the grammar.  Pay careful attention to making sure that constructs
-        // like `const const Foo()`, `const const []`, and `const const {}`
-        // lead to errors.
         listener.beginConstantPattern(const_);
-        token = parsePrecedenceExpression(
-            const_, SELECTOR_PRECEDENCE, /* allowCascades = */ false);
+        token = parsePrecedenceExpression(const_, SELECTOR_PRECEDENCE,
+            /* allowCascades = */ false, ConstantPatternContext.explicit);
         listener.endConstantPattern(const_);
         return token;
     }
@@ -9544,8 +9620,8 @@
       // suggested in https://github.com/dart-lang/language/issues/2501.
       // TODO(paulberry): update this code if necessary when that issue is
       // resolved.
-      token = parsePrecedenceExpression(
-          next, SHIFT_PRECEDENCE, /* allowCascades = */ false);
+      token = parsePrecedenceExpression(next, SHIFT_PRECEDENCE,
+          /* allowCascades = */ false, ConstantPatternContext.none);
       listener.handleRelationalPattern(operator);
       return token;
     }
@@ -9600,11 +9676,9 @@
       // It's not an object pattern so parse it as an expression.
       token = beforeFirstIdentifier;
     }
-    // TODO(paulberry): report error if this constant is not permitted by the
-    // grammar
     listener.beginConstantPattern(/* constKeyword = */ null);
-    token = parsePrecedenceExpression(
-        token, SELECTOR_PRECEDENCE, /* allowCascades = */ false);
+    token = parsePrecedenceExpression(token, SELECTOR_PRECEDENCE,
+        /* allowCascades = */ false, ConstantPatternContext.implicit);
     listener.endConstantPattern(/* constKeyword = */ null);
     return token;
   }
@@ -10141,3 +10215,40 @@
 
   const PatternContext({required this.isRefutable});
 }
+
+/// Enum describing the different contexts in which a constant pattern is
+/// parsed.
+///
+/// This restricts what expressions are allowed.
+enum ConstantPatternContext {
+  /// A constant pattern is not currently being parsed.
+  none,
+
+  /// A constant pattern without a preceding `const` is being parsed.
+  ///
+  /// For instance `e` in
+  ///
+  ///     if (o case e) {}
+  ///
+  /// Here `e` can be any valid constant pattern, but not for instance
+  /// expressions like `!foo`.
+  implicit,
+
+  /// A constant pattern with a preceding `const` is being parsed.
+  ///
+  /// For instance `e` in
+  ///
+  ///     if (o case const e) {}
+  ///
+  /// Here `e` cannot start with `const`.
+  explicit,
+
+  /// A constant pattern started with a `-` is being parsed.
+  ///
+  /// For instance `e` in
+  ///
+  ///     if (o case -e) {}
+  ///
+  /// Here `e` is only allowed to be a numeric literal.
+  numericLiteralOnly,
+}

pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml

diff --git a/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml b/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml
index 97661c1..f8ead02 100644
--- a/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml
+++ b/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml
@@ -2367,6 +2367,16 @@
   status: needsEvaluation
 ParserErrorCode.INVALID_COMMENT_REFERENCE:
   status: needsEvaluation
+ParserErrorCode.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST:
+  status: needsEvaluation
+ParserErrorCode.INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL:
+  status: needsEvaluation
+ParserErrorCode.INVALID_CONSTANT_PATTERN_GENERIC:
+  status: needsEvaluation
+ParserErrorCode.INVALID_CONSTANT_PATTERN_NEGATION:
+  status: needsEvaluation
+ParserErrorCode.INVALID_CONSTANT_PATTERN_UNARY:
+  status: needsEvaluation
 ParserErrorCode.INVALID_CONSTRUCTOR_NAME:
   status: needsEvaluation
 ParserErrorCode.INVALID_GENERIC_FUNCTION_TYPE:

pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart

diff --git a/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart b/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart
index 776ba39..e81d53b 100644
--- a/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart
+++ b/pkg/analyzer/lib/src/dart/error/syntactic_errors.g.dart
@@ -149,6 +149,11 @@
   ParserErrorCode.ABSTRACT_SEALED_CLASS,
   ParserErrorCode.EXPERIMENT_NOT_ENABLED_OFF_BY_DEFAULT,
   ParserErrorCode.ANNOTATION_SPACE_BEFORE_PARENTHESIS,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_NEGATION,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_UNARY,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_GENERIC,
 ];
 
 class ParserErrorCode extends ErrorCode {
@@ -909,6 +914,39 @@
         "start with 'new', but shouldn't contain anything else.",
   );
 
+  static const ParserErrorCode INVALID_CONSTANT_PATTERN_DUPLICATE_CONST =
+      ParserErrorCode(
+    'INVALID_CONSTANT_PATTERN_DUPLICATE_CONST',
+    "Duplicate 'const' keyword in constant expression.",
+    correctionMessage: "Try removing one of the 'const' keywords.",
+  );
+
+  static const ParserErrorCode INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL =
+      ParserErrorCode(
+    'INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL',
+    "The empty record literal is not supported as a constant pattern.",
+  );
+
+  static const ParserErrorCode INVALID_CONSTANT_PATTERN_GENERIC =
+      ParserErrorCode(
+    'INVALID_CONSTANT_PATTERN_GENERIC',
+    "This expression is not supported as a constant pattern.",
+    correctionMessage: "Try wrapping the expression in 'const ( ... )'.",
+  );
+
+  static const ParserErrorCode INVALID_CONSTANT_PATTERN_NEGATION =
+      ParserErrorCode(
+    'INVALID_CONSTANT_PATTERN_NEGATION',
+    "Only negation of a numeric literal is supported as a constant pattern.",
+    correctionMessage: "Try wrapping the expression in 'const ( ... )'.",
+  );
+
+  static const ParserErrorCode INVALID_CONSTANT_PATTERN_UNARY = ParserErrorCode(
+    'INVALID_CONSTANT_PATTERN_UNARY',
+    "The unary operator {0} is not supported as a constant pattern.",
+    correctionMessage: "Try wrapping the expression in 'const ( ... )'.",
+  );
+
   static const ParserErrorCode INVALID_CONSTRUCTOR_NAME = ParserErrorCode(
     'INVALID_CONSTRUCTOR_NAME',
     "The name of a constructor must match the name of the enclosing class.",

pkg/analyzer/lib/src/error/error_code_values.g.dart

diff --git a/pkg/analyzer/lib/src/error/error_code_values.g.dart b/pkg/analyzer/lib/src/error/error_code_values.g.dart
index c528300..d9e361c 100644
--- a/pkg/analyzer/lib/src/error/error_code_values.g.dart
+++ b/pkg/analyzer/lib/src/error/error_code_values.g.dart
@@ -789,6 +789,11 @@
   ParserErrorCode.INVALID_AWAIT_IN_FOR,
   ParserErrorCode.INVALID_CODE_POINT,
   ParserErrorCode.INVALID_COMMENT_REFERENCE,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_GENERIC,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_NEGATION,
+  ParserErrorCode.INVALID_CONSTANT_PATTERN_UNARY,
   ParserErrorCode.INVALID_CONSTRUCTOR_NAME,
   ParserErrorCode.INVALID_GENERIC_FUNCTION_TYPE,
   ParserErrorCode.INVALID_HEX_ESCAPE,

pkg/analyzer/lib/src/generated/parser.dart

diff --git a/pkg/analyzer/lib/src/generated/parser.dart b/pkg/analyzer/lib/src/generated/parser.dart
index f11abec..43b6dc3 100644
--- a/pkg/analyzer/lib/src/generated/parser.dart
+++ b/pkg/analyzer/lib/src/generated/parser.dart
@@ -190,8 +190,10 @@
 
   Expression parsePrimaryExpression() {
     currentToken = fastaParser
-        .parsePrimary(fastaParser.syntheticPreviousToken(currentToken),
-            fasta.IdentifierContext.expression)
+        .parsePrimary(
+            fastaParser.syntheticPreviousToken(currentToken),
+            fasta.IdentifierContext.expression,
+            fasta.ConstantPatternContext.none)
         .next!;
     return astBuilder.pop() as Expression;
   }

pkg/dart2wasm/lib/class_info.dart

diff --git a/pkg/dart2wasm/lib/class_info.dart b/pkg/dart2wasm/lib/class_info.dart
index 6a448aa..911f715 100644
--- a/pkg/dart2wasm/lib/class_info.dart
+++ b/pkg/dart2wasm/lib/class_info.dart
@@ -42,6 +42,11 @@
   static const byteDataViewLength = 2;
   static const byteDataViewTypedData = 3;
   static const byteDataViewOffsetInBytes = 4;
+  static const suspendStateIterator = 4;
+  static const suspendStateContext = 5;
+  static const suspendStateTargetIndex = 6;
+  static const syncStarIteratorCurrent = 3;
+  static const syncStarIteratorYieldStarIterable = 4;
 
   static void validate(Translator translator) {
     void check(Class cls, String name, int expectedIndex) {
@@ -68,6 +73,16 @@
         FieldIndex.interfaceTypeTypeArguments);
     check(translator.functionTypeClass, "namedParameters",
         FieldIndex.functionTypeNamedParameters);
+    check(translator.suspendStateClass, "_iterator",
+        FieldIndex.suspendStateIterator);
+    check(translator.suspendStateClass, "_context",
+        FieldIndex.suspendStateContext);
+    check(translator.suspendStateClass, "_targetIndex",
+        FieldIndex.suspendStateTargetIndex);
+    check(translator.syncStarIteratorClass, "_current",
+        FieldIndex.syncStarIteratorCurrent);
+    check(translator.syncStarIteratorClass, "_yieldStarIterable",
+        FieldIndex.syncStarIteratorYieldStarIterable);
   }
 }
 

pkg/dart2wasm/lib/closures.dart

diff --git a/pkg/dart2wasm/lib/closures.dart b/pkg/dart2wasm/lib/closures.dart
index 13648fc..f92dd91 100644
--- a/pkg/dart2wasm/lib/closures.dart
+++ b/pkg/dart2wasm/lib/closures.dart
@@ -920,6 +920,7 @@
         w.StructType struct = context.struct;
         if (context.parent != null) {
           assert(!context.containsThis);
+          assert(!context.parent!.isEmpty);
           struct.fields.add(w.FieldType(
               w.RefType.def(context.parent!.struct, nullable: true)));
         }
@@ -947,7 +948,9 @@
   final Closures closures;
   final Member member;
   final Map<TreeNode, int> variableDepth = {};
-  int depth = 0;
+  final List<bool> functionIsSyncStar = [false];
+
+  int get depth => functionIsSyncStar.length - 1;
 
   CaptureFinder(this.closures, this.member);
 
@@ -956,6 +959,14 @@
   w.Module get m => translator.m;
 
   @override
+  void visitFunctionNode(FunctionNode node) {
+    assert(depth == 0); // Nested function nodes are skipped by [_visitLambda].
+    functionIsSyncStar[0] = node.asyncMarker == AsyncMarker.SyncStar;
+    node.visitChildren(this);
+    functionIsSyncStar[0] = false;
+  }
+
+  @override
   void visitAssertStatement(AssertStatement node) {
     if (translator.options.enableAsserts) {
       node.visitChildren(this);
@@ -983,8 +994,9 @@
   void _visitVariableUse(TreeNode variable) {
     int declDepth = variableDepth[variable] ?? 0;
     assert(declDepth <= depth);
-    if (declDepth < depth) {
-      closures.captures[variable] = Capture(variable);
+    if (declDepth < depth || functionIsSyncStar[declDepth]) {
+      final capture = closures.captures[variable] ??= Capture(variable);
+      if (functionIsSyncStar[declDepth]) capture.written = true;
     } else if (variable is VariableDeclaration &&
         variable.parent is FunctionDeclaration) {
       closures.closurizedFunctions.add(variable.parent as FunctionDeclaration);
@@ -1004,7 +1016,7 @@
   }
 
   void _visitThis() {
-    if (depth > 0) {
+    if (depth > 0 || functionIsSyncStar[0]) {
       closures.isThisCaptured = true;
     }
   }
@@ -1058,9 +1070,9 @@
         m.addFunction(type, "$member closure at ${node.location}");
     closures.lambdas[node] = Lambda(node, function);
 
-    depth++;
+    functionIsSyncStar.add(node.asyncMarker == AsyncMarker.SyncStar);
     node.visitChildren(this);
-    depth--;
+    functionIsSyncStar.removeLast();
   }
 
   @override

pkg/dart2wasm/lib/code_generator.dart

diff --git a/pkg/dart2wasm/lib/code_generator.dart b/pkg/dart2wasm/lib/code_generator.dart
index 2435d447..8f2172f 100644
--- a/pkg/dart2wasm/lib/code_generator.dart
+++ b/pkg/dart2wasm/lib/code_generator.dart
@@ -9,6 +9,7 @@
 import 'package:dart2wasm/intrinsics.dart';
 import 'package:dart2wasm/param_info.dart';
 import 'package:dart2wasm/reference_extensions.dart';
+import 'package:dart2wasm/sync_star.dart';
 import 'package:dart2wasm/translator.dart';
 import 'package:dart2wasm/types.dart';
 
@@ -35,14 +36,13 @@
 class CodeGenerator extends ExpressionVisitor1<w.ValueType, w.ValueType>
     implements InitializerVisitor<void>, StatementVisitor<void> {
   final Translator translator;
-  final w.DefinedFunction function;
+  w.DefinedFunction function;
   final Reference reference;
   late final List<w.Local> paramLocals;
   final w.Label? returnLabel;
 
   late final Intrinsifier intrinsifier;
   late final StaticTypeContext typeContext;
-  late final w.Instructions b;
 
   late final Closures closures;
 
@@ -82,10 +82,25 @@
     this.paramLocals = paramLocals ?? function.locals;
     intrinsifier = Intrinsifier(this);
     typeContext = StaticTypeContext(member, translator.typeEnvironment);
-    b = function.body;
+  }
+
+  /// Factory constructor for instantiating a code generator appropriate for
+  /// generating code for the given function. This will either return a
+  /// [CodeGenerator] or a [SyncStarCodeGenerator].
+  factory CodeGenerator.forFunction(
+      Translator translator,
+      FunctionNode? functionNode,
+      w.DefinedFunction function,
+      Reference reference) {
+    bool isSyncStar = functionNode?.asyncMarker == AsyncMarker.SyncStar &&
+        !reference.isTearOffReference;
+    return isSyncStar
+        ? SyncStarCodeGenerator(translator, function, reference)
+        : CodeGenerator(translator, function, reference);
   }
 
   w.Module get m => translator.m;
+  w.Instructions get b => function.body;
 
   Member get member => reference.asMember;
 
@@ -180,6 +195,8 @@
       }
     }
 
+    assert(member.function!.asyncMarker != AsyncMarker.SyncStar);
+
     if (member.function!.asyncMarker == AsyncMarker.Async &&
         !reference.isAsyncInnerReference) {
       // Generate the async wrapper function, i.e. the function that gets
@@ -344,7 +361,7 @@
     stubBody.end();
   }
 
-  void generateBody(Member member) {
+  void setupParametersAndContexts(Member member) {
     ParameterInfo paramInfo = translator.paramInfoFor(reference);
     int parameterOffset = _initializeThis(member);
     int implicitParams = parameterOffset + paramInfo.typeParamCount;
@@ -433,31 +450,36 @@
 
     allocateContext(member.function!);
     captureParameters();
+  }
 
-    if (member is Constructor) {
-      Class cls = member.enclosingClass;
-      ClassInfo info = translator.classInfo[cls]!;
-      for (TypeParameter typeParam in cls.typeParameters) {
+  void generateInitializerList(Constructor member) {
+    Class cls = member.enclosingClass;
+    ClassInfo info = translator.classInfo[cls]!;
+    for (TypeParameter typeParam in cls.typeParameters) {
+      b.local_get(thisLocal!);
+      b.local_get(typeLocals[typeParam]!);
+      b.struct_set(info.struct, translator.typeParameterIndex[typeParam]!);
+    }
+    for (Field field in cls.fields) {
+      if (field.isInstanceMember &&
+          field.initializer != null &&
+          field.type is! VoidType) {
+        int fieldIndex = translator.fieldIndex[field]!;
         b.local_get(thisLocal!);
-        b.local_get(typeLocals[typeParam]!);
-        b.struct_set(info.struct, translator.typeParameterIndex[typeParam]!);
-      }
-      for (Field field in cls.fields) {
-        if (field.isInstanceMember &&
-            field.initializer != null &&
-            field.type is! VoidType) {
-          int fieldIndex = translator.fieldIndex[field]!;
-          b.local_get(thisLocal!);
-          wrap(
-              field.initializer!, info.struct.fields[fieldIndex].type.unpacked);
-          b.struct_set(info.struct, fieldIndex);
-        }
-      }
-      for (Initializer initializer in member.initializers) {
-        visitInitializer(initializer);
+        wrap(field.initializer!, info.struct.fields[fieldIndex].type.unpacked);
+        b.struct_set(info.struct, fieldIndex);
       }
     }
+    for (Initializer initializer in member.initializers) {
+      visitInitializer(initializer);
+    }
+  }
 
+  void generateBody(Member member) {
+    setupParametersAndContexts(member);
+    if (member is Constructor) {
+      generateInitializerList(member);
+    }
     Statement? body = member.function!.body;
     if (body != null) {
       visitStatement(body);
@@ -466,23 +488,10 @@
     b.end();
   }
 
-  /// Generate code for the body of a lambda.
-  w.DefinedFunction generateLambda(Lambda lambda, Closures closures) {
-    // Initialize closure information from enclosing member.
-    this.closures = closures;
-
+  void setupLambdaParametersAndContexts(Lambda lambda) {
     FunctionNode functionNode = lambda.functionNode;
     _initializeContextLocals(functionNode);
 
-    if (functionNode.asyncMarker == AsyncMarker.Async &&
-        lambda.function == function) {
-      w.DefinedFunction inner =
-          translator.functions.addAsyncInnerFunctionFor(function);
-      generateAsyncWrapper(functionNode, inner, 1);
-      return CodeGenerator(translator, inner, reference)
-          .generateLambda(lambda, closures);
-    }
-
     int paramIndex = 1;
     for (TypeParameter typeParam in functionNode.typeParameters) {
       typeLocals[typeParam] = paramLocals[paramIndex++];
@@ -496,14 +505,36 @@
 
     allocateContext(functionNode);
     captureParameters();
+  }
 
-    visitStatement(functionNode.body!);
+  /// Generate code for the body of a lambda.
+  w.DefinedFunction generateLambda(Lambda lambda, Closures closures) {
+    // Initialize closure information from enclosing member.
+    this.closures = closures;
+
+    if (lambda.functionNode.asyncMarker == AsyncMarker.Async &&
+        lambda.function == function) {
+      return generateAsyncLambdaWrapper(lambda);
+    }
+
+    setupLambdaParametersAndContexts(lambda);
+
+    visitStatement(lambda.functionNode.body!);
     _implicitReturn();
     b.end();
 
     return function;
   }
 
+  w.DefinedFunction generateAsyncLambdaWrapper(Lambda lambda) {
+    _initializeContextLocals(lambda.functionNode);
+    w.DefinedFunction inner =
+        translator.functions.addAsyncInnerFunctionFor(function);
+    generateAsyncWrapper(lambda.functionNode, inner, 1);
+    return CodeGenerator(translator, inner, reference)
+        .generateLambda(lambda, closures);
+  }
+
   /// Initialize locals containing `this` in constructors and instance members.
   /// Returns the number of parameter locals taken up by the receiver parameter,
   /// i.e. the parameter offset for the first type parameter (or the first
@@ -592,7 +623,7 @@
     Context? context = closures.contexts[node];
     if (context != null && !context.isEmpty) {
       w.Local contextLocal =
-          addLocal(w.RefType.def(context.struct, nullable: false));
+          addLocal(w.RefType.def(context.struct, nullable: true));
       context.currentLocal = contextLocal;
       b.struct_new_default(context.struct);
       b.local_set(contextLocal);
@@ -1082,7 +1113,7 @@
     return condition is LogicalExpression;
   }
 
-  void _branchIf(Expression? condition, w.Label target,
+  void branchIf(Expression? condition, w.Label target,
       {required bool negated}) {
     if (condition == null) {
       if (!negated) b.br(target);
@@ -1097,12 +1128,12 @@
           (condition.operatorEnum == LogicalExpressionOperator.AND) ^ negated;
       if (isConjunctive) {
         w.Label conditionBlock = b.block();
-        _branchIf(condition.left, conditionBlock, negated: !negated);
-        _branchIf(condition.right, target, negated: negated);
+        branchIf(condition.left, conditionBlock, negated: !negated);
+        branchIf(condition.right, target, negated: negated);
         b.end();
       } else {
-        _branchIf(condition.left, target, negated: negated);
-        _branchIf(condition.right, target, negated: negated);
+        branchIf(condition.left, target, negated: negated);
+        branchIf(condition.right, target, negated: negated);
       }
     } else {
       wrap(condition!, w.NumType.i32);
@@ -1130,13 +1161,13 @@
       w.Label ifBlock = b.block(const [], result);
       if (otherwise != null) {
         w.Label elseBlock = b.block();
-        _branchIf(condition, elseBlock, negated: true);
+        branchIf(condition, elseBlock, negated: true);
         then();
         b.br(ifBlock);
         b.end();
         otherwise();
       } else {
-        _branchIf(condition, ifBlock, negated: true);
+        branchIf(condition, ifBlock, negated: true);
         then();
       }
       b.end();
@@ -1157,7 +1188,7 @@
     w.Label loop = b.loop();
     allocateContext(node);
     visitStatement(node.body);
-    _branchIf(node.condition, loop, negated: false);
+    branchIf(node.condition, loop, negated: false);
     b.end();
   }
 
@@ -1165,7 +1196,7 @@
   void visitWhileStatement(WhileStatement node) {
     w.Label block = b.block();
     w.Label loop = b.loop();
-    _branchIf(node.condition, block, negated: true);
+    branchIf(node.condition, block, negated: true);
     allocateContext(node);
     visitStatement(node.body);
     b.br(loop);
@@ -1175,16 +1206,24 @@
 
   @override
   void visitForStatement(ForStatement node) {
-    Context? context = closures.contexts[node];
     allocateContext(node);
     for (VariableDeclaration variable in node.variables) {
       visitStatement(variable);
     }
     w.Label block = b.block();
     w.Label loop = b.loop();
-    _branchIf(node.condition, block, negated: true);
+    branchIf(node.condition, block, negated: true);
     visitStatement(node.body);
 
+    emitForStatementUpdate(node);
+
+    b.br(loop);
+    b.end();
+    b.end();
+  }
+
+  void emitForStatementUpdate(ForStatement node) {
+    Context? context = closures.contexts[node];
     if (context != null && !context.isEmpty) {
       // Create a new context for each iteration of the loop.
       w.Local oldContext = context.currentLocal;
@@ -1211,9 +1250,6 @@
     for (Expression update in node.updates) {
       wrap(update, voidMarker);
     }
-    b.br(loop);
-    b.end();
-    b.end();
   }
 
   @override
@@ -2353,7 +2389,9 @@
     Context? context = closures.contexts[functionNode]?.parent;
     if (context != null) {
       b.local_get(context.currentLocal);
-      assert(!context.currentLocal.type.nullable);
+      if (context.currentLocal.type.nullable) {
+        b.ref_as_non_null();
+      }
     } else {
       b.global_get(translator.globals.dummyStructGlobal); // Dummy context
     }

pkg/dart2wasm/lib/kernel_nodes.dart

diff --git a/pkg/dart2wasm/lib/kernel_nodes.dart b/pkg/dart2wasm/lib/kernel_nodes.dart
index ef341be..b6f1932 100644
--- a/pkg/dart2wasm/lib/kernel_nodes.dart
+++ b/pkg/dart2wasm/lib/kernel_nodes.dart
@@ -78,6 +78,14 @@
   late final Class typeUniverseClass =
       index.getClass("dart:core", "_TypeUniverse");
 
+  // dart:core sync* support classes
+  late final Class suspendStateClass =
+      index.getClass("dart:core", "_SuspendState");
+  late final Class syncStarIterableClass =
+      index.getClass("dart:core", "_SyncStarIterable");
+  late final Class syncStarIteratorClass =
+      index.getClass("dart:core", "_SyncStarIterator");
+
   // dart:ffi classes
   late final Class ffiCompoundClass = index.getClass("dart:ffi", "_Compound");
   late final Class ffiPointerClass = index.getClass("dart:ffi", "Pointer");

pkg/dart2wasm/lib/sync_star.dart

diff --git a/pkg/dart2wasm/lib/sync_star.dart b/pkg/dart2wasm/lib/sync_star.dart
new file mode 100644
index 0000000..4606b64
--- /dev/null
+++ b/pkg/dart2wasm/lib/sync_star.dart
@@ -0,0 +1,620 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:dart2wasm/class_info.dart';
+import 'package:dart2wasm/closures.dart';
+import 'package:dart2wasm/code_generator.dart';
+
+import 'package:kernel/ast.dart';
+
+import 'package:wasm_builder/wasm_builder.dart' as w;
+
+/// Placement of a control flow graph target within a statement. This
+/// distinction is necessary since some statements need to have two targets
+/// associated with them.
+///
+/// The meanings of the variants are:
+///
+///  - [Inner]: Loop entry of a [DoStatement], condition of a [ForStatement] or
+///             [WhileStatement], the `else` branch of an [IfStatement], or the
+///             initial entry target for a function body.
+///  - [After]: After a statement, the resumption point of a [YieldStatement],
+///             or the final state (iterator done) of a function body.
+enum _StateTargetPlacement { Inner, After }
+
+/// Representation of target in the `sync*` control flow graph.
+class _StateTarget {
+  int index;
+  TreeNode node;
+  _StateTargetPlacement placement;
+
+  _StateTarget(this.index, this.node, this.placement);
+
+  String toString() {
+    String place = placement == _StateTargetPlacement.Inner ? "in" : "after";
+    return "$index: $place $node";
+  }
+}
+
+/// Identify which statements contain `yield` or `yield*` statements, and assign
+/// target indices to all control flow targets of these.
+///
+/// Target indices are assigned in program order.
+class _YieldFinder extends StatementVisitor<void> {
+  final SyncStarCodeGenerator codeGen;
+
+  // The number of `yield` or `yield*` statements seen so far.
+  int yieldCount = 0;
+
+  _YieldFinder(this.codeGen);
+
+  List<_StateTarget> get targets => codeGen.targets;
+
+  void find(FunctionNode function) {
+    // Initial state
+    addTarget(function.body!, _StateTargetPlacement.Inner);
+    assert(function.body is Block || function.body is ReturnStatement);
+    recurse(function.body!);
+    // Final state
+    addTarget(function.body!, _StateTargetPlacement.After);
+  }
+
+  /// Recurse into a statement and then remove any targets added by the
+  /// statement if it doesn't contain any `yield` or `yield*` statements.
+  void recurse(Statement statement) {
+    int yieldCountIn = yieldCount;
+    int targetsIn = targets.length;
+    statement.accept(this);
+    if (yieldCount == yieldCountIn) targets.length = targetsIn;
+  }
+
+  void addTarget(TreeNode node, _StateTargetPlacement placement) {
+    targets.add(_StateTarget(targets.length, node, placement));
+  }
+
+  @override
+  void defaultStatement(Statement node) {
+    // Statements not explicitly handled in this visitor can never contain any
+    // `yield` or `yield*` statements. It is assumed that this holds for all
+    // [BlockExpression]s in the function.
+  }
+
+  @override
+  void visitBlock(Block node) {
+    for (Statement statement in node.statements) {
+      recurse(statement);
+    }
+  }
+
+  @override
+  void visitDoStatement(DoStatement node) {
+    addTarget(node, _StateTargetPlacement.Inner);
+    recurse(node.body);
+  }
+
+  @override
+  void visitForStatement(ForStatement node) {
+    addTarget(node, _StateTargetPlacement.Inner);
+    recurse(node.body);
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    recurse(node.then);
+    if (node.otherwise != null) {
+      addTarget(node, _StateTargetPlacement.Inner);
+      recurse(node.otherwise!);
+    }
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitLabeledStatement(LabeledStatement node) {
+    recurse(node.body);
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitSwitchStatement(SwitchStatement node) {
+    for (SwitchCase c in node.cases) {
+      addTarget(c, _StateTargetPlacement.Inner);
+      recurse(c.body);
+    }
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitTryCatch(TryCatch node) {
+    recurse(node.body);
+    for (Catch c in node.catches) {
+      addTarget(c, _StateTargetPlacement.Inner);
+      recurse(c.body);
+    }
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitTryFinally(TryFinally node) {
+    recurse(node.body);
+    addTarget(node, _StateTargetPlacement.Inner);
+    recurse(node.finalizer);
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitWhileStatement(WhileStatement node) {
+    addTarget(node, _StateTargetPlacement.Inner);
+    recurse(node.body);
+    addTarget(node, _StateTargetPlacement.After);
+  }
+
+  @override
+  void visitYieldStatement(YieldStatement node) {
+    yieldCount++;
+    addTarget(node, _StateTargetPlacement.After);
+  }
+}
+
+/// A specialized code generator for generating code for `sync*` functions.
+///
+/// This will create an "outer" function which is a small function that just
+/// instantiates and returns a [_SyncStarIterable], plus an "inner" function
+/// containing the body of the `sync*` function.
+///
+/// For the inner function, all statements containing any `yield` or `yield*`
+/// statements will be translated to an explicit control flow graph implemented
+/// via a switch (via the Wasm `br_table` instruction) in a loop. This enables
+/// the function to suspend its execution at yield points and jump back to the
+/// point of suspension when the execution is resumed.
+///
+/// Local state is preserved via the closure contexts, which will implicitly
+/// capture all local variables in a `sync*` function even if they are not
+/// captured by any lambdas.
+class SyncStarCodeGenerator extends CodeGenerator {
+  SyncStarCodeGenerator(super.translator, super.function, super.reference);
+
+  /// Targets of the CFG, indexed by target index.
+  final List<_StateTarget> targets = [];
+
+  // Targets categorized by placement and indexed by node.
+  final Map<TreeNode, _StateTarget> innerTargets = {};
+  final Map<TreeNode, _StateTarget> afterTargets = {};
+
+  /// The loop around the switch.
+  late final w.Label masterLoop;
+
+  /// The target labels of the switch, indexed by target index.
+  late final List<w.Label> labels;
+
+  /// The target index of the entry label for the current `sync*` CFG node.
+  int currentTargetIndex = -1;
+
+  // Locals containing special values.
+  late final w.Local suspendStateLocal;
+  late final w.Local pendingExceptionLocal;
+  late final w.Local pendingStackTraceLocal;
+  late final w.Local targetIndexLocal;
+
+  late final ClassInfo suspendStateInfo =
+      translator.classInfo[translator.suspendStateClass]!;
+  late final ClassInfo syncStarIterableInfo =
+      translator.classInfo[translator.syncStarIterableClass]!;
+  late final ClassInfo syncStarIteratorInfo =
+      translator.classInfo[translator.syncStarIteratorClass]!;
+
+  @override
+  void generate() {
+    closures = Closures(this);
+    setupParametersAndContexts(member);
+    generateBodies(member.function!);
+  }
+
+  @override
+  w.DefinedFunction generateLambda(Lambda lambda, Closures closures) {
+    this.closures = closures;
+    setupLambdaParametersAndContexts(lambda);
+    generateBodies(lambda.functionNode);
+    return function;
+  }
+
+  void generateBodies(FunctionNode functionNode) {
+    // Number and categorize CFG targets.
+    _YieldFinder(this).find(functionNode);
+    for (final target in targets) {
+      switch (target.placement) {
+        case _StateTargetPlacement.Inner:
+          innerTargets[target.node] = target;
+          break;
+        case _StateTargetPlacement.After:
+          afterTargets[target.node] = target;
+          break;
+      }
+    }
+
+    // Wasm function containing the body of the `sync*` function.
+    final w.DefinedFunction resumeFun = m.addFunction(
+        m.addFunctionType([
+          suspendStateInfo.nonNullableType,
+          translator.topInfo.nullableType,
+          translator.stackTraceInfo.nullableType
+        ], const [
+          w.NumType.i32
+        ]),
+        "${function.functionName} inner");
+
+    Context? context = closures.contexts[functionNode];
+    if (context != null && context.isEmpty) context = context.parent;
+    generateOuter(functionNode, context, resumeFun);
+    generateInner(functionNode, context, resumeFun);
+  }
+
+  void generateOuter(FunctionNode functionNode, Context? context,
+      w.DefinedFunction resumeFun) {
+    // Instantiate a [_SyncStarIterable] containing the context and resume
+    // function for this `sync*` function.
+    DartType returnType = functionNode.returnType;
+    DartType elementType = returnType is InterfaceType &&
+            returnType.classNode == translator.coreTypes.iterableClass
+        ? returnType.typeArguments.single
+        : DynamicType();
+    translator.functions.allocateClass(syncStarIterableInfo.classId);
+    b.i32_const(syncStarIterableInfo.classId);
+    b.i32_const(initialIdentityHash);
+    types.makeType(this, elementType);
+    if (context != null) {
+      assert(!context.isEmpty);
+      b.local_get(context.currentLocal);
+    } else {
+      b.ref_null(w.HeapType.struct);
+    }
+    b.global_get(translator.makeFunctionRef(resumeFun));
+    b.struct_new(syncStarIterableInfo.struct);
+    b.end();
+  }
+
+  /// Clones the context pointed to by the [srcContext] local. Returns a local
+  /// pointing to the cloned context.
+  ///
+  /// It is assumed that the context is the function-level context for the
+  /// `sync*` function.
+  w.Local cloneContext(
+      FunctionNode functionNode, Context context, w.Local srcContext) {
+    assert(context.owner == functionNode);
+
+    final w.Local destContext = addLocal(context.currentLocal.type);
+    b.struct_new_default(context.struct);
+    b.local_set(destContext);
+
+    void copyCapture(TreeNode node) {
+      Capture? capture = closures.captures[node];
+      if (capture != null) {
+        assert(capture.context == context);
+        b.local_get(destContext);
+        b.local_get(srcContext);
+        b.struct_get(context.struct, capture.fieldIndex);
+        b.struct_set(context.struct, capture.fieldIndex);
+      }
+    }
+
+    if (context.containsThis) {
+      b.local_get(destContext);
+      b.local_get(srcContext);
+      b.struct_get(context.struct, context.thisFieldIndex);
+      b.struct_set(context.struct, context.thisFieldIndex);
+    }
+    if (context.parent != null) {
+      b.local_get(destContext);
+      b.local_get(srcContext);
+      b.struct_get(context.struct, context.parentFieldIndex);
+      b.struct_set(context.struct, context.parentFieldIndex);
+    }
+    functionNode.positionalParameters.forEach(copyCapture);
+    functionNode.namedParameters.forEach(copyCapture);
+    functionNode.typeParameters.forEach(copyCapture);
+
+    return destContext;
+  }
+
+  void generateInner(FunctionNode functionNode, Context? context,
+      w.DefinedFunction resumeFun) {
+    // Set the current Wasm function for the code generator to the inner
+    // function of the `sync*`, which is to contain the body.
+    function = resumeFun;
+
+    // Parameters passed from [_SyncStarIterator.moveNext].
+    suspendStateLocal = function.locals[0];
+    pendingExceptionLocal = function.locals[1];
+    pendingStackTraceLocal = function.locals[2];
+
+    // Set up locals for contexts and `this`.
+    thisLocal = null;
+    Context? localContext = context;
+    while (localContext != null) {
+      if (!localContext.isEmpty) {
+        localContext.currentLocal = function
+            .addLocal(w.RefType.def(localContext.struct, nullable: true));
+        if (localContext.containsThis) {
+          assert(thisLocal == null);
+          thisLocal = function.addLocal(localContext
+              .struct.fields[localContext.thisFieldIndex].type.unpacked
+              .withNullability(false));
+          translator.globals.instantiateDummyValue(b, thisLocal!.type);
+          b.local_set(thisLocal!);
+
+          preciseThisLocal = thisLocal;
+        }
+      }
+      localContext = localContext.parent;
+    }
+
+    // Read target index from the suspend state.
+    targetIndexLocal = addLocal(w.NumType.i32);
+    b.local_get(suspendStateLocal);
+    b.struct_get(suspendStateInfo.struct, FieldIndex.suspendStateTargetIndex);
+    b.local_set(targetIndexLocal);
+
+    // Switch on the target index.
+    masterLoop = b.loop(const [], const [w.NumType.i32]);
+    labels = List.generate(targets.length, (_) => b.block()).reversed.toList();
+    w.Label defaultLabel = b.block();
+    b.local_get(targetIndexLocal);
+    b.br_table(labels, defaultLabel);
+    b.end(); // defaultLabel
+    b.unreachable();
+
+    // Initial state, executed on first [moveNext] on the iterator.
+    _StateTarget initialTarget = targets.first;
+    emitTargetLabel(initialTarget);
+
+    // Clone context on first execution.
+    restoreContextsAndThis(context, cloneContextFor: functionNode);
+
+    visitStatement(functionNode.body!);
+
+    // Final state: just keep returning.
+    emitTargetLabel(targets.last);
+    emitReturn();
+    b.end(); // masterLoop
+
+    b.end();
+  }
+
+  void emitTargetLabel(_StateTarget target) {
+    currentTargetIndex++;
+    assert(target.index == currentTargetIndex);
+    b.end();
+  }
+
+  void emitReturn() {
+    // Set state target to final state.
+    b.local_get(suspendStateLocal);
+    b.i32_const(targets.last.index);
+    b.struct_set(suspendStateInfo.struct, FieldIndex.suspendStateTargetIndex);
+
+    // Return `false`.
+    b.i32_const(0);
+    b.return_();
+  }
+
+  void jumpToTarget(_StateTarget target,
+      {Expression? condition, bool negated = false}) {
+    if (condition == null && negated) return;
+    if (target.index > currentTargetIndex) {
+      // Forward jump directly to the label.
+      branchIf(condition, labels[target.index], negated: negated);
+    } else {
+      // Backward jump via the switch.
+      w.Label block = b.block();
+      branchIf(condition, block, negated: !negated);
+      b.i32_const(target.index);
+      b.local_set(targetIndexLocal);
+      b.br(masterLoop);
+      b.end(); // block
+    }
+  }
+
+  void restoreContextsAndThis(Context? context,
+      {FunctionNode? cloneContextFor}) {
+    if (context != null) {
+      assert(!context.isEmpty);
+      b.local_get(suspendStateLocal);
+      b.struct_get(suspendStateInfo.struct, FieldIndex.suspendStateContext);
+      b.ref_cast(context.currentLocal.type as w.RefType);
+      b.local_set(context.currentLocal);
+
+      if (context.owner == cloneContextFor) {
+        context.currentLocal =
+            cloneContext(cloneContextFor!, context, context.currentLocal);
+      }
+
+      while (context!.parent != null) {
+        assert(!context.parent!.isEmpty);
+        b.local_get(context.currentLocal);
+        b.struct_get(context.struct, context.parentFieldIndex);
+        b.ref_as_non_null();
+        context = context.parent!;
+        b.local_set(context.currentLocal);
+      }
+      if (context.containsThis) {
+        b.local_get(context.currentLocal);
+        b.struct_get(context.struct, context.thisFieldIndex);
+        b.ref_as_non_null();
+        b.local_set(thisLocal!);
+      }
+    }
+  }
+
+  @override
+  void visitDoStatement(DoStatement node) {
+    _StateTarget? inner = innerTargets[node];
+    if (inner == null) return super.visitDoStatement(node);
+
+    emitTargetLabel(inner);
+    allocateContext(node);
+    visitStatement(node.body);
+    jumpToTarget(inner, condition: node.condition);
+  }
+
+  @override
+  void visitForStatement(ForStatement node) {
+    _StateTarget? inner = innerTargets[node];
+    if (inner == null) return super.visitForStatement(node);
+    _StateTarget after = afterTargets[node]!;
+
+    allocateContext(node);
+    for (VariableDeclaration variable in node.variables) {
+      visitStatement(variable);
+    }
+    emitTargetLabel(inner);
+    jumpToTarget(after, condition: node.condition, negated: true);
+    visitStatement(node.body);
+
+    emitForStatementUpdate(node);
+
+    jumpToTarget(inner);
+    emitTargetLabel(after);
+  }
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    _StateTarget? after = afterTargets[node];
+    if (after == null) return super.visitIfStatement(node);
+    _StateTarget? inner = innerTargets[node];
+
+    jumpToTarget(inner ?? after, condition: node.condition, negated: true);
+    visitStatement(node.then);
+    if (node.otherwise != null) {
+      jumpToTarget(after);
+      emitTargetLabel(inner!);
+      visitStatement(node.otherwise!);
+    }
+    emitTargetLabel(after);
+  }
+
+  @override
+  void visitLabeledStatement(LabeledStatement node) {
+    _StateTarget? after = afterTargets[node];
+    if (after == null) return super.visitLabeledStatement(node);
+
+    visitStatement(node.body);
+    emitTargetLabel(after);
+  }
+
+  @override
+  void visitBreakStatement(BreakStatement node) {
+    _StateTarget? target = afterTargets[node.target];
+    if (target == null) return super.visitBreakStatement(node);
+
+    jumpToTarget(target);
+  }
+
+  @override
+  void visitSwitchStatement(SwitchStatement node) {
+    _StateTarget? after = afterTargets[node];
+    if (after == null) return super.visitSwitchStatement(node);
+
+    // TODO(51342): Implement this.
+    unimplemented(node, "switch in sync*", const []);
+  }
+
+  @override
+  void visitTryCatch(TryCatch node) {
+    _StateTarget? after = afterTargets[node];
+    if (after == null) return super.visitTryCatch(node);
+
+    // TODO(51343): implement this.
+    unimplemented(node, "try/catch in sync*", const []);
+  }
+
+  @override
+  void visitTryFinally(TryFinally node) {
+    _StateTarget? after = afterTargets[node];
+    if (after == null) return super.visitTryFinally(node);
+
+    // TODO(51343): implement this.
+    unimplemented(node, "try/finally in sync*", const []);
+  }
+
+  @override
+  void visitWhileStatement(WhileStatement node) {
+    _StateTarget? inner = innerTargets[node];
+    if (inner == null) return super.visitWhileStatement(node);
+    _StateTarget after = afterTargets[node]!;
+
+    emitTargetLabel(inner);
+    jumpToTarget(after, condition: node.condition, negated: true);
+    allocateContext(node);
+    visitStatement(node.body);
+    jumpToTarget(inner);
+    emitTargetLabel(after);
+  }
+
+  @override
+  void visitYieldStatement(YieldStatement node) {
+    _StateTarget after = afterTargets[node]!;
+
+    // Evaluate operand and store it to `_current` for `yield` or
+    // `_yieldStarIterable` for `yield*`.
+    b.local_get(suspendStateLocal);
+    b.struct_get(suspendStateInfo.struct, FieldIndex.suspendStateIterator);
+    wrap(node.expression, translator.topInfo.nullableType);
+    if (node.isYieldStar) {
+      b.ref_cast(translator.objectInfo.nonNullableType);
+      b.struct_set(syncStarIteratorInfo.struct,
+          FieldIndex.syncStarIteratorYieldStarIterable);
+    } else {
+      b.struct_set(
+          syncStarIteratorInfo.struct, FieldIndex.syncStarIteratorCurrent);
+    }
+
+    // Find the current context.
+    Context? context;
+    TreeNode contextOwner = node;
+    do {
+      contextOwner = contextOwner.parent!;
+      context = closures.contexts[contextOwner];
+    } while (
+        contextOwner.parent != null && (context == null || context.isEmpty));
+
+    // Store context.
+    if (context != null) {
+      assert(!context.isEmpty);
+      b.local_get(suspendStateLocal);
+      b.local_get(context.currentLocal);
+      b.struct_set(suspendStateInfo.struct, FieldIndex.suspendStateContext);
+    }
+
+    // Set state target to label after yield.
+    b.local_get(suspendStateLocal);
+    b.i32_const(after.index);
+    b.struct_set(suspendStateInfo.struct, FieldIndex.suspendStateTargetIndex);
+
+    // Return `true`.
+    b.i32_const(1);
+    b.return_();
+
+    // Resume.
+    emitTargetLabel(after);
+
+    // For `yield*`, check for pending exception.
+    if (node.isYieldStar) {
+      w.Label exceptionCheck = b.block();
+      b.local_get(pendingExceptionLocal);
+      b.br_on_null(exceptionCheck);
+      b.local_get(pendingStackTraceLocal);
+      b.ref_as_non_null();
+      b.throw_(translator.exceptionTag);
+      b.end(); // exceptionCheck
+    }
+
+    restoreContextsAndThis(context);
+  }
+
+  @override
+  void visitReturnStatement(ReturnStatement node) {
+    assert(node.expression == null);
+    emitReturn();
+  }
+}

pkg/dart2wasm/lib/transformers.dart

diff --git a/pkg/dart2wasm/lib/transformers.dart b/pkg/dart2wasm/lib/transformers.dart
index 1d43a1b..608bc8a0 100644
--- a/pkg/dart2wasm/lib/transformers.dart
+++ b/pkg/dart2wasm/lib/transformers.dart
@@ -8,8 +8,6 @@
 import 'package:kernel/target/targets.dart';
 import 'package:kernel/type_environment.dart';
 import 'package:kernel/type_algebra.dart';
-import 'package:_fe_analyzer_shared/src/messages/codes.dart'
-    show messageWasmSyncStar;
 
 void transformLibraries(List<Library> libraries, CoreTypes coreTypes,
     ClassHierarchy hierarchy, DiagnosticReporter diagnosticReporter) {
@@ -646,10 +644,6 @@
       _enclosingIsAsyncStar = false;
       return super.visitFunctionNode(functionNode);
     } else {
-      if (functionNode.dartAsyncMarker == AsyncMarker.SyncStar) {
-        diagnosticReporter?.report(messageWasmSyncStar, functionNode.fileOffset,
-            1, functionNode.location?.file);
-      }
       bool previousEnclosing = _enclosingIsAsyncStar;
       TreeNode result = super.visitFunctionNode(functionNode);
       _enclosingIsAsyncStar = previousEnclosing;

pkg/dart2wasm/lib/translator.dart

diff --git a/pkg/dart2wasm/lib/translator.dart b/pkg/dart2wasm/lib/translator.dart
index 76d6323..91e0193 100644
--- a/pkg/dart2wasm/lib/translator.dart
+++ b/pkg/dart2wasm/lib/translator.dart
@@ -319,18 +319,20 @@
       if (options.exportAll && exportName == null) {
         m.exportFunction(canonicalName, function);
       }
-      var codeGen = CodeGenerator(this, function, reference);
+
+      final CodeGenerator codeGen =
+          CodeGenerator.forFunction(this, member.function, function, reference);
       codeGen.generate();
 
       if (options.printWasm) {
-        print(function.type);
-        print(function.body.trace);
+        print(codeGen.function.type);
+        print(codeGen.function.body.trace);
       }
 
       for (Lambda lambda in codeGen.closures.lambdas.values) {
-        w.DefinedFunction lambdaFunction =
-            CodeGenerator(this, lambda.function, reference)
-                .generateLambda(lambda, codeGen.closures);
+        w.DefinedFunction lambdaFunction = CodeGenerator.forFunction(
+                this, lambda.functionNode, lambda.function, reference)
+            .generateLambda(lambda, codeGen.closures);
         _printFunction(lambdaFunction, "$canonicalName (closure)");
       }
 
@@ -874,6 +876,7 @@
   bool shouldInline(Reference target) {
     if (!options.inlining) return false;
     Member member = target.asMember;
+    if (member.function?.asyncMarker == AsyncMarker.SyncStar) return false;
     if (membersContainingInnerFunctions.contains(member)) return false;
     if (membersBeingGenerated.contains(member)) return false;
     if (member is Field) return true;

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

diff --git a/pkg/front_end/lib/src/fasta/source/source_function_builder.dart b/pkg/front_end/lib/src/fasta/source/source_function_builder.dart
index 7c74b5f..9409085 100644
--- a/pkg/front_end/lib/src/fasta/source/source_function_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_function_builder.dart
@@ -10,6 +10,7 @@
 import '../../api_prototype/lowering_predicates.dart';
 import '../builder/builder.dart';
 import '../builder/class_builder.dart';
+import '../builder/constructor_builder.dart';
 import '../builder/declaration_builder.dart';
 import '../builder/formal_parameter_builder.dart';
 import '../builder/function_builder.dart';
@@ -424,7 +425,8 @@
 
   @override
   VariableDeclaration getFormalParameter(int index) {
-    if (isExtensionInstanceMember || isInlineClassInstanceMember) {
+    if (this is! ConstructorBuilder &&
+        (isExtensionInstanceMember || isInlineClassInstanceMember)) {
       return formals![index + 1].variable!;
     } else {
       return formals![index].variable!;

pkg/front_end/messages.status

diff --git a/pkg/front_end/messages.status b/pkg/front_end/messages.status
index 47ec16e..e29e76b 100644
--- a/pkg/front_end/messages.status
+++ b/pkg/front_end/messages.status
@@ -994,8 +994,6 @@
 VariableCouldBeNullDueToWrite/analyzerCode: Fail
 VariableCouldBeNullDueToWrite/example: Fail
 VariablePatternTypeMismatchInSwitchHeads/analyzerCode: Fail
-WasmSyncStar/analyzerCode: Fail
-WasmSyncStar/example: Fail
 WeakWithStrongDillLibrary/analyzerCode: Fail
 WeakWithStrongDillLibrary/example: Fail
 WebLiteralCannotBeRepresentedExactly/analyzerCode: Fail

pkg/front_end/messages.yaml

diff --git a/pkg/front_end/messages.yaml b/pkg/front_end/messages.yaml
index fcece67..720037c 100644
--- a/pkg/front_end/messages.yaml
+++ b/pkg/front_end/messages.yaml
@@ -2,6 +2,18 @@
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
+# Run
+#
+#     dart run pkg/front_end/tool/_fasta/generate_messages.dart
+#
+# to regenerate messages after having edited this file.
+#
+# If entries with 'analyzerCode' and 'index' have been changed, run
+#
+#     dart run pkg/analyzer/tool/messages/generate.dart
+#
+# to regenerate analyzer messages.
+
 # Each entry in this map corresponds to a diagnostic message. Ideally, each
 # entry contains three parts:
 #
@@ -1680,10 +1692,6 @@
   problemMessage: "'yield' can only be used in 'sync*' or 'async*' methods."
   analyzerCode: YIELD_IN_NON_GENERATOR
 
-WasmSyncStar:
-  problemMessage: "Compilation to Wasm does not support 'sync*'."
-  severity: WARNING
-
 OnlyTry:
   index: 20
   problemMessage: "A try block must be followed by an 'on', 'catch', or 'finally' clause."
@@ -6353,6 +6361,62 @@
       if (x case int(5)) {}
     }
 
+InvalidConstantPatternNegation:
+  problemMessage: "Only negation of a numeric literal is supported as a constant pattern."
+  correctionMessage: "Try wrapping the expression in 'const ( ... )'."
+  experiments: patterns
+  analyzerCode: ParserErrorCode.INVALID_CONSTANT_PATTERN_NEGATION
+  index: 135
+  script: |
+    method(x) {
+      const y = 5;
+      if (x case -y) {}
+    }
+
+InvalidConstantPatternUnary:
+  problemMessage: "The unary operator #name is not supported as a constant pattern."
+  correctionMessage: "Try wrapping the expression in 'const ( ... )'."
+  experiments: patterns
+  analyzerCode: ParserErrorCode.INVALID_CONSTANT_PATTERN_UNARY
+  index: 136
+  script: |
+    method(x) {
+      const y = false;
+      if (x case !y) {}
+    }
+
+InvalidConstantPatternDuplicateConst:
+  problemMessage: "Duplicate 'const' keyword in constant expression."
+  correctionMessage: "Try removing one of the 'const' keywords."
+  analyzerCode: ParserErrorCode.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+  index: 137
+  experiments: patterns
+  script: |
+    method(x) {
+      if (x case const const []) {}
+    }
+
+InvalidConstantPatternEmptyRecordLiteral:
+  problemMessage: "The empty record literal is not supported as a constant pattern."
+  analyzerCode: ParserErrorCode.INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL
+  index: 138
+  experiments: patterns,records
+  script: |
+    method(x) {
+      if (x case const ()) {}
+    }
+
+InvalidConstantPatternGeneric:
+  problemMessage: "This expression is not supported as a constant pattern."
+  correctionMessage: "Try wrapping the expression in 'const ( ... )'."
+  analyzerCode: ParserErrorCode.INVALID_CONSTANT_PATTERN_GENERIC
+  index: 139
+  experiments: patterns
+  script: |
+    method(x) {
+      if (x case List<int>) {}
+    }
+
 PatternAssignmentDeclaresVariable:
   problemMessage: "Variable '#name' can't be declared in a pattern assignment."
   correctionMessage: "Try using a preexisting variable or changing the assignment to a pattern variable declaration."

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

diff --git a/pkg/front_end/parser_testcases/augmentation/augment_super.dart.intertwined.expect b/pkg/front_end/parser_testcases/augmentation/augment_super.dart.intertwined.expect
index 4f1fd20..8a312d7 100644
--- a/pkg/front_end/parser_testcases/augmentation/augment_super.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/augmentation/augment_super.dart.intertwined.expect
@@ -31,9 +31,9 @@
               parseExpressionStatementOrDeclaration({, null)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseAugmentSuperExpression({, expression)
                             listener: handleAugmentSuperExpression(augment, super, expression)
                             listener: handleNoTypeArguments(()
@@ -103,9 +103,9 @@
                   looksLikeLocalFunction(augment)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
@@ -155,29 +155,29 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(return, null)
                           parseExpression(...)
-                            parsePrecedenceExpression(..., 1, true)
-                              parseUnaryExpression(..., true)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(..., true, ConstantPatternContext.none)
+                                parsePrimary(..., expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression(..., expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
                           listener: handleSpreadExpression(...)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression(,, expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
                               parseArgumentOrIndexStar(super, Instance of 'NoTypeParamOrArg', false)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(0)
                                 listener: handleIndexedExpression(null, [, ])
@@ -234,22 +234,22 @@
               parseExpressionStatementOrDeclaration({, null)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseAugmentSuperExpression({, expression)
                             listener: handleAugmentSuperExpression(augment, super, expression)
                       parseArgumentOrIndexStar(super, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(null, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)
@@ -261,9 +261,9 @@
                                 listener: handleSend(value, [)
                         parseArgumentOrIndexStar(value, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                           listener: handleIndexedExpression(null, [, ])
@@ -276,14 +276,14 @@
               parseExpressionStatementOrDeclaration(;, null)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseAugmentSuperExpression(;, expression)
                             listener: handleAugmentSuperExpression(augment, super, expression)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)
@@ -329,9 +329,9 @@
               parseExpressionStatementOrDeclaration({, null)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseAugmentSuperExpression({, expression)
                             listener: handleAugmentSuperExpression(augment, super, expression)
                             listener: handleNoTypeArguments(()
@@ -348,9 +348,9 @@
               parseExpressionStatementOrDeclaration(;, null)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseAugmentSuperExpression(;, expression)
                             listener: handleAugmentSuperExpression(augment, super, expression)
                   ensureSemicolon(super)
@@ -387,9 +387,9 @@
                   looksLikeLocalFunction(augment)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
@@ -463,9 +463,9 @@
                       parseExpressionStatementOrDeclaration({, null)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression({, expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
                                     listener: handleNoTypeArguments(()
@@ -539,9 +539,9 @@
                           looksLikeLocalFunction(augment)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     inPlainSync()
                                     parseSendOrFunctionLiteral(;, expression)
                                       parseSend(;, expression)
@@ -591,9 +591,9 @@
                       parseExpressionStatementOrDeclaration({, null)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression({, expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
                               listener: handleUnaryPostfixAssignmentExpression(++)
@@ -607,11 +607,11 @@
                           looksLikeLocalFunction(--)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrecedenceExpression(--, 16, true)
-                                    parseUnaryExpression(--, true)
-                                      parsePrimary(--, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrecedenceExpression(--, 16, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(--, true, ConstantPatternContext.none)
+                                      parsePrimary(--, expression, ConstantPatternContext.none)
                                         parseAugmentSuperExpression(--, expression)
                                           listener: handleAugmentSuperExpression(augment, super, expression)
                                   listener: handleUnaryPrefixAssignmentExpression(--)
@@ -623,11 +623,11 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrecedenceExpression(-, 16, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseAugmentSuperExpression(-, expression)
                                       listener: handleAugmentSuperExpression(augment, super, expression)
                               listener: handleUnaryPrefixExpression(-)
@@ -683,14 +683,14 @@
                       parseExpressionStatementOrDeclaration({, null)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression({, expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
-                              parsePrecedenceExpression(=, 1, true)
-                                parseUnaryExpression(=, true)
-                                  parsePrimary(=, expression)
+                              parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                  parsePrimary(=, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(=, expression)
                                       parseSend(=, expression)
                                         isNextIdentifier(=)
@@ -740,9 +740,9 @@
                       parseExpressionStatementOrDeclaration({, null)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression({, expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
                                     listener: handleNoTypeArguments(()
@@ -759,9 +759,9 @@
                       parseExpressionStatementOrDeclaration(;, null)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseAugmentSuperExpression(;, expression)
                                     listener: handleAugmentSuperExpression(augment, super, expression)
                           ensureSemicolon(super)
@@ -798,9 +798,9 @@
                           looksLikeLocalFunction(augment)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     inPlainSync()
                                     parseSendOrFunctionLiteral(;, expression)
                                       parseSend(;, expression)

pkg/front_end/parser_testcases/augmentation/member_declarations.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/augmentation/member_declarations.dart.intertwined.expect b/pkg/front_end/parser_testcases/augmentation/member_declarations.dart.intertwined.expect
index 588079b..e9abcb1 100644
--- a/pkg/front_end/parser_testcases/augmentation/member_declarations.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/augmentation/member_declarations.dart.intertwined.expect
@@ -113,9 +113,9 @@
                 parseFunctionBody(getter, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralNull(=>)
                               listener: handleLiteralNull(null)
                     ensureSemicolon(null)
@@ -150,9 +150,9 @@
                 parseFunctionBody(getter, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -271,9 +271,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -293,9 +293,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -450,9 +450,9 @@
                 parseFunctionBody(getter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralNull(=>)
                               listener: handleLiteralNull(null)
                     ensureSemicolon(null)
@@ -486,9 +486,9 @@
                 parseFunctionBody(getter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -605,9 +605,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -627,9 +627,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -810,9 +810,9 @@
               parseFunctionBody(getter, false, true)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralNull(=>)
                             listener: handleLiteralNull(null)
                   ensureSemicolon(null)
@@ -847,9 +847,9 @@
               parseFunctionBody(getter, false, true)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralInt(=>)
                             listener: handleLiteralInt(0)
                   ensureSemicolon(0)
@@ -968,9 +968,9 @@
               parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Mixin, Mixin)
                 listener: beginFieldInitializer(=)
                 parseExpression(=)
-                  parsePrecedenceExpression(=, 1, true)
-                    parseUnaryExpression(=, true)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseLiteralInt(=)
                           listener: handleLiteralInt(0)
                 listener: endFieldInitializer(=, ;)
@@ -990,9 +990,9 @@
               parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Mixin, Mixin)
                 listener: beginFieldInitializer(=)
                 parseExpression(=)
-                  parsePrecedenceExpression(=, 1, true)
-                    parseUnaryExpression(=, true)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseLiteralInt(=)
                           listener: handleLiteralInt(0)
                 listener: endFieldInitializer(=, ;)
@@ -1147,9 +1147,9 @@
               parseFunctionBody(getter, false, false)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralNull(=>)
                             listener: handleLiteralNull(null)
                   ensureSemicolon(null)
@@ -1183,9 +1183,9 @@
               parseFunctionBody(getter, false, false)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralInt(=>)
                             listener: handleLiteralInt(0)
                   ensureSemicolon(0)
@@ -1302,9 +1302,9 @@
               parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Mixin, Mixin)
                 listener: beginFieldInitializer(=)
                 parseExpression(=)
-                  parsePrecedenceExpression(=, 1, true)
-                    parseUnaryExpression(=, true)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseLiteralInt(=)
                           listener: handleLiteralInt(0)
                 listener: endFieldInitializer(=, ;)
@@ -1324,9 +1324,9 @@
               parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Mixin, Mixin)
                 listener: beginFieldInitializer(=)
                 parseExpression(=)
-                  parsePrecedenceExpression(=, 1, true)
-                    parseUnaryExpression(=, true)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseLiteralInt(=)
                           listener: handleLiteralInt(0)
                 listener: endFieldInitializer(=, ;)

pkg/front_end/parser_testcases/augmentation/member_errors.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/augmentation/member_errors.dart.intertwined.expect b/pkg/front_end/parser_testcases/augmentation/member_errors.dart.intertwined.expect
index c95f9bd..3161f4d 100644
--- a/pkg/front_end/parser_testcases/augmentation/member_errors.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/augmentation/member_errors.dart.intertwined.expect
@@ -245,9 +245,9 @@
                 parseFunctionBody(getter, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralNull(=>)
                               listener: handleLiteralNull(null)
                     ensureSemicolon(null)
@@ -340,9 +340,9 @@
                 parseFunctionBody(getter, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -727,9 +727,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -785,9 +785,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -1191,9 +1191,9 @@
                 parseFunctionBody(getter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralNull(=>)
                               listener: handleLiteralNull(null)
                     ensureSemicolon(null)
@@ -1227,9 +1227,9 @@
                 parseFunctionBody(getter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralNull(=>)
                               listener: handleLiteralNull(null)
                     ensureSemicolon(null)
@@ -1265,9 +1265,9 @@
                 parseFunctionBody(getter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -1303,9 +1303,9 @@
                 parseFunctionBody(getter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -1531,9 +1531,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -1555,9 +1555,9 @@
                 parseFieldInitializerOpt(field, field, null, null, null, null, final, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -1579,9 +1579,9 @@
                 parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -1603,9 +1603,9 @@
                 parseFieldInitializerOpt(field, field, null, null, null, null, const, DeclarationKind.Class, Class)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)

pkg/front_end/parser_testcases/augmentation/top_level_declarations.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/augmentation/top_level_declarations.dart.intertwined.expect b/pkg/front_end/parser_testcases/augmentation/top_level_declarations.dart.intertwined.expect
index c4fbe57..400d7c0 100644
--- a/pkg/front_end/parser_testcases/augmentation/top_level_declarations.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/augmentation/top_level_declarations.dart.intertwined.expect
@@ -79,9 +79,9 @@
         parseFunctionBody(getter, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -112,9 +112,9 @@
         parseFunctionBody(getter, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(0)
             ensureSemicolon(0)
@@ -226,9 +226,9 @@
         parseFieldInitializerOpt(field, field, null, null, augment, null, final, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(0)
           listener: endFieldInitializer(=, ;)
@@ -248,9 +248,9 @@
         parseFieldInitializerOpt(field, field, null, null, augment, null, const, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(0)
           listener: endFieldInitializer(=, ;)

pkg/front_end/parser_testcases/augmentation/top_level_errors.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/augmentation/top_level_errors.dart.intertwined.expect b/pkg/front_end/parser_testcases/augmentation/top_level_errors.dart.intertwined.expect
index 461002a..1ce5168 100644
--- a/pkg/front_end/parser_testcases/augmentation/top_level_errors.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/augmentation/top_level_errors.dart.intertwined.expect
@@ -195,9 +195,9 @@
         parseFunctionBody(getter, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -280,9 +280,9 @@
         parseFunctionBody(getter, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(0)
             ensureSemicolon(0)
@@ -640,9 +640,9 @@
         parseFieldInitializerOpt(field, field, null, null, augment, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(0)
           listener: endFieldInitializer(=, ;)

pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.intertwined.expect
index dd5722c0..baa89d0 100644
--- a/pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/enhanced_enums/entries_with_type_arguments.dart.intertwined.expect
@@ -106,9 +106,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralInt(()
                         listener: handleLiteralInt(42)
               listener: endArguments(1, (, ))

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
index 4aa4e44..dd4c269 100644
--- a/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
@@ -31,9 +31,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
                         isNextIdentifier(=>)
@@ -43,7 +43,7 @@
                         parseArgumentsOpt(Future)
                           listener: handleNoArguments(.)
                         listener: handleSend(Future, .)
-                parsePrimary(., expressionContinuation)
+                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     looksLikeFunctionBody(;)
                     parseSend(., expressionContinuation)
@@ -94,16 +94,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement({)
                 parseExpression({)
-                  parsePrecedenceExpression({, 1, true)
-                    parseUnaryExpression({, true)
+                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression({, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression({, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression({, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 looksLikeFunctionBody(;)
                                 parseSend(await, expression)

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

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 ad8fc74..660e28e 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
@@ -33,22 +33,22 @@
                   looksLikeLocalFunction([)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix({, null)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
-                                        parseParenthesizedExpressionOrRecordLiteral([, null)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral([, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   listener: handleNoTypeArguments([)
                                                   parseLiteralListSuffix((, null)
                                                     listener: handleLiteralList(0, [, null, ])
@@ -92,22 +92,22 @@
                   looksLikeLocalFunction([)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix({, null)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
-                                        parseParenthesizedExpressionOrRecordLiteral([, null)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral([, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
                                                     ensureIdentifier((, expression)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect
index 9617e9c..85b6f75 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect
@@ -104,9 +104,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
@@ -121,15 +121,15 @@
                                           ensureIdentifier((, namedArgumentReference)
                                             listener: handleIdentifier(c, namedArgumentReference)
                                           parseExpression(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   listener: handleNoTypeArguments([)
                                                   parseLiteralListSuffix(:, null)
                                                     parseExpression([)
-                                                      parsePrecedenceExpression([, 1, true)
-                                                        parseUnaryExpression([, true)
-                                                          parsePrimary([, expression)
+                                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                          parsePrimary([, expression, ConstantPatternContext.none)
                                                             parseSendOrFunctionLiteral([, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend([, expression)
@@ -144,15 +144,15 @@
                                                                       ensureIdentifier((, namedArgumentReference)
                                                                         listener: handleIdentifier(c, namedArgumentReference)
                                                                       parseExpression(:)
-                                                                        parsePrecedenceExpression(:, 1, true)
-                                                                          parseUnaryExpression(:, true)
-                                                                            parsePrimary(:, expression)
+                                                                        parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                                                          parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                                            parsePrimary(:, expression, ConstantPatternContext.none)
                                                                               listener: handleNoTypeArguments([)
                                                                               parseLiteralListSuffix(:, null)
                                                                                 parseExpression([)
-                                                                                  parsePrecedenceExpression([, 1, true)
-                                                                                    parseUnaryExpression([, true)
-                                                                                      parsePrimary([, expression)
+                                                                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                                                      parsePrimary([, expression, ConstantPatternContext.none)
                                                                                         parseSendOrFunctionLiteral([, expression)
                                                                                           looksLikeFunctionBody(,)
                                                                                           parseSend([, expression)
@@ -167,9 +167,9 @@
                                                                                                   listener: endArguments(0, (, ))
                                                                                             listener: handleSend(C, ,)
                                                                                 parseExpression(,)
-                                                                                  parsePrecedenceExpression(,, 1, true)
-                                                                                    parseUnaryExpression(,, true)
-                                                                                      parsePrimary(,, expression)
+                                                                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                                                                         parseSendOrFunctionLiteral(,, expression)
                                                                                           looksLikeFunctionBody(,)
                                                                                           parseSend(,, expression)
@@ -184,9 +184,9 @@
                                                                                                   listener: endArguments(0, (, ))
                                                                                             listener: handleSend(C, ,)
                                                                                 parseExpression(,)
-                                                                                  parsePrecedenceExpression(,, 1, true)
-                                                                                    parseUnaryExpression(,, true)
-                                                                                      parsePrimary(,, expression)
+                                                                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                                                                         parseSendOrFunctionLiteral(,, expression)
                                                                                           looksLikeFunctionBody(,)
                                                                                           parseSend(,, expression)
@@ -205,9 +205,9 @@
                                                                       listener: endArguments(1, (, ))
                                                                 listener: handleSend(C, ,)
                                                     parseExpression(,)
-                                                      parsePrecedenceExpression(,, 1, true)
-                                                        parseUnaryExpression(,, true)
-                                                          parsePrimary(,, expression)
+                                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
@@ -222,9 +222,9 @@
                                                                       listener: endArguments(0, (, ))
                                                                 listener: handleSend(C, ,)
                                                     parseExpression(,)
-                                                      parsePrecedenceExpression(,, 1, true)
-                                                        parseUnaryExpression(,, true)
-                                                          parsePrimary(,, expression)
+                                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
@@ -355,9 +355,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
@@ -372,15 +372,15 @@
                                           ensureIdentifier((, namedArgumentReference)
                                             listener: handleIdentifier(d, namedArgumentReference)
                                           parseExpression(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   listener: handleNoTypeArguments([)
                                                   parseLiteralListSuffix(:, null)
                                                     parseExpression([)
-                                                      parsePrecedenceExpression([, 1, true)
-                                                        parseUnaryExpression([, true)
-                                                          parsePrimary([, expression)
+                                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                          parsePrimary([, expression, ConstantPatternContext.none)
                                                             parseSendOrFunctionLiteral([, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend([, expression)
@@ -395,9 +395,9 @@
                                                                       ensureIdentifier((, namedArgumentReference)
                                                                         listener: handleIdentifier(d, namedArgumentReference)
                                                                       parseExpression(:)
-                                                                        parsePrecedenceExpression(:, 1, true)
-                                                                          parseUnaryExpression(:, true)
-                                                                            parsePrimary(:, expression)
+                                                                        parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                                                          parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                                            parsePrimary(:, expression, ConstantPatternContext.none)
                                                                               parseSendOrFunctionLiteral(:, expression)
                                                                                 looksLikeFunctionBody(,)
                                                                                 parseSend(:, expression)
@@ -413,9 +413,9 @@
                                                                                   listener: handleSend(D, ,)
                                                                       listener: handleNamedArgument(:)
                                                                       parseExpression(,)
-                                                                        parsePrecedenceExpression(,, 1, true)
-                                                                          parseUnaryExpression(,, true)
-                                                                            parsePrimary(,, expression)
+                                                                        parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                                          parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                                            parsePrimary(,, expression, ConstantPatternContext.none)
                                                                               parseSendOrFunctionLiteral(,, expression)
                                                                                 looksLikeFunctionBody(,)
                                                                                 parseSend(,, expression)
@@ -430,9 +430,9 @@
                                                                                         listener: endArguments(0, (, ))
                                                                                   listener: handleSend(D, ,)
                                                                       parseExpression(,)
-                                                                        parsePrecedenceExpression(,, 1, true)
-                                                                          parseUnaryExpression(,, true)
-                                                                            parsePrimary(,, expression)
+                                                                        parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                                          parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                                            parsePrimary(,, expression, ConstantPatternContext.none)
                                                                               parseSendOrFunctionLiteral(,, expression)
                                                                                 looksLikeFunctionBody(,)
                                                                                 parseSend(,, expression)
@@ -447,9 +447,9 @@
                                                                                         listener: endArguments(0, (, ))
                                                                                   listener: handleSend(D, ,)
                                                                       parseExpression(,)
-                                                                        parsePrecedenceExpression(,, 1, true)
-                                                                          parseUnaryExpression(,, true)
-                                                                            parsePrimary(,, expression)
+                                                                        parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                                          parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                                            parsePrimary(,, expression, ConstantPatternContext.none)
                                                                               parseSend(,, expression)
                                                                                 isNextIdentifier(,)
                                                                                 ensureIdentifier(,, expression)
@@ -467,9 +467,9 @@
                                                                       listener: endArguments(4, (, ))
                                                                 listener: handleSend(D, ,)
                                                     parseExpression(,)
-                                                      parsePrecedenceExpression(,, 1, true)
-                                                        parseUnaryExpression(,, true)
-                                                          parsePrimary(,, expression)
+                                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
@@ -484,9 +484,9 @@
                                                                       listener: endArguments(0, (, ))
                                                                 listener: handleSend(D, ,)
                                                     parseExpression(,)
-                                                      parsePrecedenceExpression(,, 1, true)
-                                                        parseUnaryExpression(,, true)
-                                                          parsePrimary(,, expression)
+                                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_02.dart.intertwined.expect
index d1371b4..9fe2ae8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_02.dart.intertwined.expect
@@ -39,9 +39,9 @@
                         looksLikeLocalFunction([)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   listener: handleNoTypeArguments([)
                                   parseLiteralListSuffix({, null)
                                     listener: handleLiteralList(0, [, null, ])

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect
index 39fee7c..b660499 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect
@@ -38,9 +38,9 @@
                       looksLikeLocalFunction(foo)
                       parseExpressionStatement({)
                         parseExpression({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral({, expression)
                                   looksLikeFunctionBody())
                                   parseSend({, expression)
@@ -67,9 +67,9 @@
                         looksLikeLocalFunction())
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSend(;, expression)
                                     isNextIdentifier(;)
                                     ensureIdentifier(;, expression)

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

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 e5e8db9..c9768f5 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
@@ -32,9 +32,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -47,10 +47,10 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -71,9 +71,9 @@
                                                           looksLikeLocalFunction(bar)
                                                           parseExpressionStatement({)
                                                             parseExpression({)
-                                                              parsePrecedenceExpression({, 1, true)
-                                                                parseUnaryExpression({, true)
-                                                                  parsePrimary({, expression)
+                                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                                     parseSendOrFunctionLiteral({, expression)
                                                                       looksLikeFunctionBody())
                                                                       parseSend({, expression)
@@ -100,9 +100,9 @@
                                                             looksLikeLocalFunction())
                                                             parseExpressionStatement(;)
                                                               parseExpression(;)
-                                                                parsePrecedenceExpression(;, 1, true)
-                                                                  parseUnaryExpression(;, true)
-                                                                    parsePrimary(;, expression)
+                                                                parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                                                    parsePrimary(;, expression, ConstantPatternContext.none)
                                                                       parseSend(;, expression)
                                                                         isNextIdentifier(;)
                                                                         ensureIdentifier(;, expression)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_05.dart.intertwined.expect
index 84329b0..4a0b0df 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_05.dart.intertwined.expect
@@ -39,15 +39,15 @@
                         looksLikeLocalFunction([)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   listener: handleNoTypeArguments([)
                                   parseLiteralListSuffix({, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralInt([)
                                               listener: handleLiteralInt(1)
                                     listener: handleLiteralList(1, [, null, ])

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect
index 6d6a27b..6f1e938 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect
@@ -34,9 +34,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             parseNewExpression({)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -52,9 +52,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSend((, expression)
                                             isNextIdentifier(()
                                             ensureIdentifier((, expression)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect
index a84a466..ce6c89a 100644
--- a/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect
@@ -45,9 +45,9 @@
                     parseVariableInitializerOpt(æFoo)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralInt(=)
                                 listener: handleLiteralInt(42)
                       listener: endVariableInitializer(=)
@@ -73,9 +73,9 @@
                     parseVariableInitializerOpt(fooÆ)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralInt(=)
                                 listener: handleLiteralInt(42)
                       listener: endVariableInitializer(=)
@@ -101,9 +101,9 @@
                     parseVariableInitializerOpt(foo)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralInt(=)
                                 listener: handleLiteralInt(42)
                       listener: endVariableInitializer(=)
@@ -117,9 +117,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -132,9 +132,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -155,9 +155,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -170,9 +170,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -193,9 +193,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -208,9 +208,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect
index 2b5d32a..0af271b 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect
@@ -94,9 +94,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -106,9 +106,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -153,9 +153,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -165,9 +165,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -210,9 +210,9 @@
                 parseFunctionBody(Foo, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -252,9 +252,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)
@@ -301,9 +301,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -353,9 +353,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)
@@ -395,9 +395,9 @@
                       listener: beginInitializer(bla)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -407,9 +407,9 @@
                                     parseArgumentsOpt(bla)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bla, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -423,9 +423,9 @@
                 parseFunctionBody(null, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -467,9 +467,9 @@
                       listener: beginInitializer(bla)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -479,9 +479,9 @@
                                     parseArgumentsOpt(bla)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bla, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -500,9 +500,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)
@@ -545,9 +545,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -593,9 +593,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)
@@ -642,9 +642,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -694,9 +694,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)
@@ -736,9 +736,9 @@
                       listener: beginInitializer(bla)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -748,9 +748,9 @@
                                     parseArgumentsOpt(bla)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bla, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -764,9 +764,9 @@
                 parseFunctionBody(null, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(0)
                     ensureSemicolon(0)
@@ -808,9 +808,9 @@
                       listener: beginInitializer(bla)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -820,9 +820,9 @@
                                     parseArgumentsOpt(bla)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bla, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -841,9 +841,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)
@@ -882,9 +882,9 @@
                       listener: beginInitializer(bla)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -894,9 +894,9 @@
                                     parseArgumentsOpt(bla)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bla, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -943,9 +943,9 @@
                       listener: beginInitializer(bla)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -955,9 +955,9 @@
                                     parseArgumentsOpt(bla)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bla, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -977,9 +977,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(0)
                         ensureSemicolon(0)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect
index bd3533a..c7880e1 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect
@@ -93,9 +93,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -105,9 +105,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -155,9 +155,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -167,9 +167,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect
index d068ce3..9206219 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect
@@ -94,9 +94,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -106,9 +106,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -154,9 +154,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -166,9 +166,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect
index e119cca4..b86c04d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect
@@ -93,9 +93,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -105,9 +105,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -153,9 +153,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -165,9 +165,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect
index daa7d61..d19679b 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect
@@ -87,9 +87,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -99,9 +99,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -186,9 +186,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -198,9 +198,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect
index 6f7452d..0c68452 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect
@@ -84,9 +84,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -96,9 +96,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -181,9 +181,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -193,9 +193,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.intertwined.expect
index cfc7adc..b63cdc8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_operator.crash_dart.intertwined.expect
@@ -95,9 +95,9 @@
                           parseSuperInitializerExpression(:)
                             parseInitializerExpressionRest(:)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseSuperExpression(:, expression)
                                         listener: handleSuperExpression(super, expression)
                                         listener: handleNoTypeArguments(()
@@ -201,9 +201,9 @@
                           parseSuperInitializerExpression(:)
                             parseInitializerExpressionRest(:)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseSuperExpression(:, expression)
                                         listener: handleSuperExpression(super, expression)
                                         listener: handleNoTypeArguments(()
@@ -296,9 +296,9 @@
                           parseSuperInitializerExpression(:)
                             parseInitializerExpressionRest(:)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseSuperExpression(:, expression)
                                         listener: handleSuperExpression(super, expression)
                                         listener: handleNoTypeArguments(()
@@ -402,9 +402,9 @@
                           parseSuperInitializerExpression(:)
                             parseInitializerExpressionRest(:)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseSuperExpression(:, expression)
                                         listener: handleSuperExpression(super, expression)
                                         listener: handleNoTypeArguments(()

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect
index 6b1a782..47bbdc1 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect
@@ -84,9 +84,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -96,9 +96,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -183,9 +183,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -195,9 +195,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect
index b5a419d..09eeacb 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect
@@ -83,9 +83,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -95,9 +95,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)
@@ -182,9 +182,9 @@
                       listener: beginInitializer(initializer)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -194,9 +194,9 @@
                                     parseArgumentsOpt(initializer)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(initializer, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralBool(=)
                                     listener: handleLiteralBool(true)
                             listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect
index 705e626..7ca66c7 100644
--- a/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect
@@ -36,9 +36,9 @@
                     parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, ForPartsContext(null))
                 parseForLoopPartsMid((, await, for)
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseSend((, expression)
                             isNextIdentifier(()
                             ensureIdentifier((, expression)
@@ -59,9 +59,9 @@
                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
                     listener: beginForInExpression())
                     parseExpression(in)
-                      parsePrecedenceExpression(in, 1, true)
-                        parseUnaryExpression(in, true)
-                          parsePrimary(in, expression)
+                      parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(in, true, ConstantPatternContext.none)
+                          parsePrimary(in, expression, ConstantPatternContext.none)
                             parseSend(in, expression)
                               isNextIdentifier(in)
                               ensureIdentifier(in, expression)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect
index a2fda33..b8be7ec 100644
--- a/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect
@@ -36,9 +36,9 @@
                     parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, ForPartsContext(null))
                 parseForLoopPartsMid((, null, for)
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseSend((, expression)
                             isNextIdentifier(()
                             ensureIdentifier((, expression)
@@ -59,9 +59,9 @@
                       rewriter()
                     parseExpressionStatement(;)
                       parseExpression(;)
-                        parsePrecedenceExpression(;, 1, true)
-                          parseUnaryExpression(;, true)
-                            parsePrimary(;, expression)
+                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                            parsePrimary(;, expression, ConstantPatternContext.none)
                               parseSend(;, expression)
                                 isNextIdentifier(;)
                                 ensureIdentifier(;, expression)

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

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 8284ed9..78a11ae 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
@@ -117,9 +117,9 @@
               parseFunctionBody(b, false, true)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralInt(=>)
                             listener: handleLiteralInt(0)
                   ensureSemicolon(0)
@@ -220,9 +220,9 @@
                 looksLikeLocalFunction(l)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -232,7 +232,7 @@
                               parseArgumentsOpt(l)
                                 listener: handleNoArguments(.)
                               listener: handleSend(l, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -325,16 +325,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -344,7 +344,7 @@
                                             parseArgumentsOpt(l)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(l, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect
index 597fb3f..9b7b3fd 100644
--- a/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect
@@ -57,27 +57,27 @@
                   parseForInLoopPartsRest(i, null, for, null, i)
                     listener: beginForInExpression([)
                     parseExpression(:)
-                      parsePrecedenceExpression(:, 1, true)
-                        parseUnaryExpression(:, true)
-                          parsePrimary(:, expression)
+                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                          parsePrimary(:, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(:, null)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralInt([)
                                         listener: handleLiteralInt(1)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(2)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(3)
                               listener: handleLiteralList(3, [, null, ])
@@ -97,9 +97,9 @@
                               looksLikeLocalFunction(print)
                               parseExpressionStatement({)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral({, expression)
                                           looksLikeFunctionBody(;)
                                           parseSend({, expression)
@@ -112,9 +112,9 @@
                                                 parseArgumentsRest(()
                                                   listener: beginArguments(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
                                                               isNextIdentifier(()

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_000032.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_000032.dart.intertwined.expect
index 8a767ce..44c762e 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_000032.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_000032.dart.intertwined.expect
@@ -94,9 +94,9 @@
                 looksLikeLocalFunction(C)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -107,9 +107,9 @@
                                 listener: handleNoArguments(<)
                               listener: handleSend(C, <)
                       listener: beginBinaryExpression(<)
-                      parsePrecedenceExpression(<, 9, true)
-                        parseUnaryExpression(<, true)
-                          parsePrimary(<, expression)
+                      parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                        parseUnaryExpression(<, true, ConstantPatternContext.none)
+                          parsePrimary(<, expression, ConstantPatternContext.none)
                             parseSend(<, expression)
                               isNextIdentifier(<)
                               ensureIdentifier(<, expression)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect
index c2d4ede..3a87169 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect
@@ -16,9 +16,9 @@
         parseFieldInitializerOpt(annotation, annotation, null, null, null, null, const, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralNull(=)
                     listener: handleLiteralNull(null)
           listener: endFieldInitializer(=, ;)
@@ -194,9 +194,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseNewExpression(=>)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
index 6d9f9b9..d7827b8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 parseFunctionBody(a, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -64,7 +64,7 @@
                                 parseArgumentsOpt(runtimeType)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(runtimeType, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -76,11 +76,11 @@
                               listener: handleSend(hashCode, xor)
                         listener: handleEndingBinaryExpression(.)
                         rewriter()
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseLiteralNull(^)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -90,12 +90,12 @@
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                         rewriter()
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseLiteralNull(^)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -139,9 +139,9 @@
                 parseFunctionBody(b, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -151,7 +151,7 @@
                                 parseArgumentsOpt(runtimeType)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(runtimeType, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -163,12 +163,12 @@
                               listener: handleSend(hashCode, ^)
                         listener: handleEndingBinaryExpression(.)
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseLiteralNull(^)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -217,9 +217,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -229,7 +229,7 @@
                                     parseArgumentsOpt(runtimeType)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(runtimeType, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -241,11 +241,11 @@
                                   listener: handleSend(hashCode, xor)
                             listener: handleEndingBinaryExpression(.)
                             rewriter()
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseLiteralNull(^)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -255,12 +255,12 @@
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                             rewriter()
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseLiteralNull(^)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -311,9 +311,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -323,7 +323,7 @@
                                     parseArgumentsOpt(runtimeType)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(runtimeType, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -335,12 +335,12 @@
                                   listener: handleSend(hashCode, ^)
                             listener: handleEndingBinaryExpression(.)
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseLiteralNull(^)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -386,15 +386,15 @@
                 parseFunctionBody(e, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -404,7 +404,7 @@
                                   parseArgumentsOpt(runtimeType)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(runtimeType, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -418,30 +418,30 @@
                           rewriter()
                         listener: endBinaryExpression(+)
                         rewriter()
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseLiteralNull(^)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                         reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                         rewriter()
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseLiteralNull(^)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -453,9 +453,9 @@
                                 listener: handleSend(hashCode, +)
                           listener: handleEndingBinaryExpression(.)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -492,15 +492,15 @@
                 parseFunctionBody(f, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -510,7 +510,7 @@
                                   parseArgumentsOpt(runtimeType)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(runtimeType, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -523,12 +523,12 @@
                           listener: handleEndingBinaryExpression(.)
                         listener: endBinaryExpression(+)
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseLiteralNull(^)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -540,9 +540,9 @@
                                 listener: handleSend(hashCode, +)
                           listener: handleEndingBinaryExpression(.)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -584,15 +584,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -602,7 +602,7 @@
                                       parseArgumentsOpt(runtimeType)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(runtimeType, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -616,30 +616,30 @@
                               rewriter()
                             listener: endBinaryExpression(+)
                             rewriter()
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseLiteralNull(^)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                             reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                             rewriter()
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseLiteralNull(^)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -651,9 +651,9 @@
                                     listener: handleSend(hashCode, +)
                               listener: handleEndingBinaryExpression(.)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -697,15 +697,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -715,7 +715,7 @@
                                       parseArgumentsOpt(runtimeType)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(runtimeType, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -728,12 +728,12 @@
                               listener: handleEndingBinaryExpression(.)
                             listener: endBinaryExpression(+)
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseLiteralNull(^)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -745,9 +745,9 @@
                                     listener: handleSend(hashCode, +)
                               listener: handleEndingBinaryExpression(.)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -813,9 +813,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -826,9 +826,9 @@
                                   listener: handleNoArguments(xor)
                                 listener: handleSend(x, xor)
                         rewriter()
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
                                   isNextIdentifier(^)
@@ -838,9 +838,9 @@
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                         rewriter()
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
                                   isNextIdentifier(^)
@@ -910,9 +910,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -923,9 +923,9 @@
                                   listener: handleNoArguments(^)
                                 listener: handleSend(x, ^)
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
                                   isNextIdentifier(^)
@@ -1000,9 +1000,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1013,9 +1013,9 @@
                                       listener: handleNoArguments(xor)
                                     listener: handleSend(x, xor)
                             rewriter()
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
                                       isNextIdentifier(^)
@@ -1025,9 +1025,9 @@
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                             rewriter()
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
                                       isNextIdentifier(^)
@@ -1104,9 +1104,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1117,9 +1117,9 @@
                                       listener: handleNoArguments(^)
                                     listener: handleSend(x, ^)
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
                                       isNextIdentifier(^)
@@ -1209,9 +1209,9 @@
                             parseVariableInitializerOpt(z)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1222,9 +1222,9 @@
                                             listener: handleNoArguments(xor)
                                           listener: handleSend(x, xor)
                                   rewriter()
-                                  parsePrecedenceExpression(^, 11, true)
-                                    parseUnaryExpression(^, true)
-                                      parsePrimary(^, expression)
+                                  parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                      parsePrimary(^, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
                                             isNextIdentifier(^)
@@ -1234,9 +1234,9 @@
                                     listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                   rewriter()
                                   listener: beginBinaryExpression(^)
-                                  parsePrecedenceExpression(^, 11, true)
-                                    parseUnaryExpression(^, true)
-                                      parsePrimary(^, expression)
+                                  parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                      parsePrimary(^, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
                                             isNextIdentifier(^)
@@ -1257,9 +1257,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1348,9 +1348,9 @@
                             parseVariableInitializerOpt(z)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1361,9 +1361,9 @@
                                             listener: handleNoArguments(^)
                                           listener: handleSend(x, ^)
                                   listener: beginBinaryExpression(^)
-                                  parsePrecedenceExpression(^, 11, true)
-                                    parseUnaryExpression(^, true)
-                                      parsePrimary(^, expression)
+                                  parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                      parsePrimary(^, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
                                             isNextIdentifier(^)
@@ -1384,9 +1384,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1457,15 +1457,15 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -1478,25 +1478,25 @@
                           rewriter()
                         listener: endBinaryExpression(+)
                         rewriter()
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
                                   isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                   parseArgumentsOpt(y)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                         reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                         rewriter()
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
                                   isNextIdentifier(^)
@@ -1507,9 +1507,9 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -1573,15 +1573,15 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -1593,9 +1593,9 @@
                                   listener: handleSend(x, ^)
                         listener: endBinaryExpression(+)
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrimary(^, expression)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrimary(^, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
                                   isNextIdentifier(^)
@@ -1606,9 +1606,9 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -1677,15 +1677,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -1698,25 +1698,25 @@
                               rewriter()
                             listener: endBinaryExpression(+)
                             rewriter()
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
                                       isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                       parseArgumentsOpt(y)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                             reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                             rewriter()
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
                                       isNextIdentifier(^)
@@ -1727,9 +1727,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -1800,15 +1800,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -1820,9 +1820,9 @@
                                       listener: handleSend(x, ^)
                             listener: endBinaryExpression(+)
                             listener: beginBinaryExpression(^)
-                            parsePrecedenceExpression(^, 11, true)
-                              parseUnaryExpression(^, true)
-                                parsePrimary(^, expression)
+                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                parsePrimary(^, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
                                       isNextIdentifier(^)
@@ -1833,9 +1833,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -1906,9 +1906,9 @@
                         looksLikeLocalFunction(s)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -1921,9 +1921,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -1934,9 +1934,9 @@
                                                           listener: handleNoArguments(xor)
                                                         listener: handleSend(x, xor)
                                                 rewriter()
-                                                parsePrecedenceExpression(^, 11, true)
-                                                  parseUnaryExpression(^, true)
-                                                    parsePrimary(^, expression)
+                                                parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                    parsePrimary(^, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
                                                           isNextIdentifier(^)
@@ -1946,9 +1946,9 @@
                                                   listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                                 rewriter()
                                                 listener: beginBinaryExpression(^)
-                                                parsePrecedenceExpression(^, 11, true)
-                                                  parseUnaryExpression(^, true)
-                                                    parsePrimary(^, expression)
+                                                parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                    parsePrimary(^, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
                                                           isNextIdentifier(^)
@@ -1960,9 +1960,9 @@
                                                           listener: handleSend(y, ,)
                                                 listener: endBinaryExpression(^)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
                                                         isNextIdentifier(,)
@@ -1973,9 +1973,9 @@
                                                           listener: handleNoArguments(xor)
                                                         listener: handleSend(x, xor)
                                                 rewriter()
-                                                parsePrecedenceExpression(^, 11, true)
-                                                  parseUnaryExpression(^, true)
-                                                    parsePrimary(^, expression)
+                                                parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                    parsePrimary(^, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
                                                           isNextIdentifier(^)
@@ -1985,9 +1985,9 @@
                                                   listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                                 rewriter()
                                                 listener: beginBinaryExpression(^)
-                                                parsePrecedenceExpression(^, 11, true)
-                                                  parseUnaryExpression(^, true)
-                                                    parsePrimary(^, expression)
+                                                parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                    parsePrimary(^, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
                                                           isNextIdentifier(^)
@@ -2009,9 +2009,9 @@
                         looksLikeLocalFunction(s)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(;, expression)
@@ -2024,9 +2024,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -2037,9 +2037,9 @@
                                                           listener: handleNoArguments(^)
                                                         listener: handleSend(x, ^)
                                                 listener: beginBinaryExpression(^)
-                                                parsePrecedenceExpression(^, 11, true)
-                                                  parseUnaryExpression(^, true)
-                                                    parsePrimary(^, expression)
+                                                parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                    parsePrimary(^, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
                                                           isNextIdentifier(^)
@@ -2051,9 +2051,9 @@
                                                           listener: handleSend(y, ,)
                                                 listener: endBinaryExpression(^)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
                                                         isNextIdentifier(,)
@@ -2064,9 +2064,9 @@
                                                           listener: handleNoArguments(^)
                                                         listener: handleSend(x, ^)
                                                 listener: beginBinaryExpression(^)
-                                                parsePrecedenceExpression(^, 11, true)
-                                                  parseUnaryExpression(^, true)
-                                                    parsePrimary(^, expression)
+                                                parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                    parsePrimary(^, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
                                                           isNextIdentifier(^)
@@ -2136,9 +2136,9 @@
                       listener: beginInitializer(foo)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -2148,9 +2148,9 @@
                                     parseArgumentsOpt(foo)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(foo, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2161,9 +2161,9 @@
                                         listener: handleNoArguments(xor)
                                       listener: handleSend(x, xor)
                               rewriter()
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)
@@ -2173,9 +2173,9 @@
                                 listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                               rewriter()
                               listener: beginBinaryExpression(^)
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)
@@ -2192,9 +2192,9 @@
                       listener: beginInitializer(bar)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -2204,9 +2204,9 @@
                                     parseArgumentsOpt(bar)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bar, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2217,9 +2217,9 @@
                                         listener: handleNoArguments(xor)
                                       listener: handleSend(x, xor)
                               rewriter()
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)
@@ -2229,9 +2229,9 @@
                                 listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                               rewriter()
                               listener: beginBinaryExpression(^)
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)
@@ -2258,9 +2258,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -2273,16 +2273,16 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello )
                                                         parseExpression(${)
-                                                          parsePrecedenceExpression(${, 1, true)
-                                                            parseUnaryExpression(${, true)
-                                                              parsePrimary(${, expression)
+                                                          parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                              parsePrimary(${, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
                                                                     isNextIdentifier(${)
@@ -2293,9 +2293,9 @@
                                                                       listener: handleNoArguments(xor)
                                                                     listener: handleSend(x, xor)
                                                             rewriter()
-                                                            parsePrecedenceExpression(^, 11, true)
-                                                              parseUnaryExpression(^, true)
-                                                                parsePrimary(^, expression)
+                                                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                                parsePrimary(^, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(^, expression)
                                                                     parseSend(^, expression)
                                                                       isNextIdentifier(^)
@@ -2305,9 +2305,9 @@
                                                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}], xor, xor)
                                                             rewriter()
                                                             listener: beginBinaryExpression(^)
-                                                            parsePrecedenceExpression(^, 11, true)
-                                                              parseUnaryExpression(^, true)
-                                                                parsePrimary(^, expression)
+                                                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                                parsePrimary(^, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(^, expression)
                                                                     parseSend(^, expression)
                                                                       isNextIdentifier(^)
@@ -2381,9 +2381,9 @@
                       listener: beginInitializer(foo)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -2393,9 +2393,9 @@
                                     parseArgumentsOpt(foo)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(foo, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2406,9 +2406,9 @@
                                         listener: handleNoArguments(^)
                                       listener: handleSend(x, ^)
                               listener: beginBinaryExpression(^)
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)
@@ -2425,9 +2425,9 @@
                       listener: beginInitializer(bar)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -2437,9 +2437,9 @@
                                     parseArgumentsOpt(bar)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bar, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2450,9 +2450,9 @@
                                         listener: handleNoArguments(^)
                                       listener: handleSend(x, ^)
                               listener: beginBinaryExpression(^)
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)
@@ -2479,9 +2479,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -2494,16 +2494,16 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello )
                                                         parseExpression(${)
-                                                          parsePrecedenceExpression(${, 1, true)
-                                                            parseUnaryExpression(${, true)
-                                                              parsePrimary(${, expression)
+                                                          parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                              parsePrimary(${, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
                                                                     isNextIdentifier(${)
@@ -2514,9 +2514,9 @@
                                                                       listener: handleNoArguments(^)
                                                                     listener: handleSend(x, ^)
                                                             listener: beginBinaryExpression(^)
-                                                            parsePrecedenceExpression(^, 11, true)
-                                                              parseUnaryExpression(^, true)
-                                                                parsePrimary(^, expression)
+                                                            parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                                                parsePrimary(^, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(^, expression)
                                                                     parseSend(^, expression)
                                                                       isNextIdentifier(^)
@@ -2622,9 +2622,9 @@
                         looksLikeLocalFunction(y)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2643,9 +2643,9 @@
                         looksLikeLocalFunction(x)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2656,9 +2656,9 @@
                                         listener: handleNoArguments(^)
                                       listener: handleSend(x, ^)
                               listener: beginBinaryExpression(^)
-                              parsePrecedenceExpression(^, 11, true)
-                                parseUnaryExpression(^, true)
-                                  parsePrimary(^, expression)
+                              parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                  parsePrimary(^, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
                                         isNextIdentifier(^)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
index 3015667..6bb1d12 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 parseFunctionBody(a, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -64,7 +64,7 @@
                                 parseArgumentsOpt(runtimeType)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(runtimeType, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -76,11 +76,11 @@
                               listener: handleSend(hashCode, and)
                         listener: handleEndingBinaryExpression(.)
                         rewriter()
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseLiteralNull(&)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -90,12 +90,12 @@
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseLiteralNull(&)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -139,9 +139,9 @@
                 parseFunctionBody(b, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -151,7 +151,7 @@
                                 parseArgumentsOpt(runtimeType)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(runtimeType, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -163,12 +163,12 @@
                               listener: handleSend(hashCode, &)
                         listener: handleEndingBinaryExpression(.)
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseLiteralNull(&)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -217,9 +217,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -229,7 +229,7 @@
                                     parseArgumentsOpt(runtimeType)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(runtimeType, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -241,11 +241,11 @@
                                   listener: handleSend(hashCode, and)
                             listener: handleEndingBinaryExpression(.)
                             rewriter()
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseLiteralNull(&)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -255,12 +255,12 @@
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                             rewriter()
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseLiteralNull(&)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -311,9 +311,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -323,7 +323,7 @@
                                     parseArgumentsOpt(runtimeType)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(runtimeType, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -335,12 +335,12 @@
                                   listener: handleSend(hashCode, &)
                             listener: handleEndingBinaryExpression(.)
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseLiteralNull(&)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -386,15 +386,15 @@
                 parseFunctionBody(e, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -404,7 +404,7 @@
                                   parseArgumentsOpt(runtimeType)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(runtimeType, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -419,30 +419,30 @@
                           rewriter()
                         listener: endBinaryExpression(+)
                         rewriter()
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseLiteralNull(&)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseLiteralNull(&)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -454,9 +454,9 @@
                                 listener: handleSend(hashCode, +)
                           listener: handleEndingBinaryExpression(.)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -493,15 +493,15 @@
                 parseFunctionBody(f, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -511,7 +511,7 @@
                                   parseArgumentsOpt(runtimeType)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(runtimeType, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -524,12 +524,12 @@
                           listener: handleEndingBinaryExpression(.)
                         listener: endBinaryExpression(+)
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseLiteralNull(&)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -541,9 +541,9 @@
                                 listener: handleSend(hashCode, +)
                           listener: handleEndingBinaryExpression(.)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -585,15 +585,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -603,7 +603,7 @@
                                       parseArgumentsOpt(runtimeType)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(runtimeType, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -618,30 +618,30 @@
                               rewriter()
                             listener: endBinaryExpression(+)
                             rewriter()
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseLiteralNull(&)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                             reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                             rewriter()
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseLiteralNull(&)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -653,9 +653,9 @@
                                     listener: handleSend(hashCode, +)
                               listener: handleEndingBinaryExpression(.)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -699,15 +699,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -717,7 +717,7 @@
                                       parseArgumentsOpt(runtimeType)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(runtimeType, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -730,12 +730,12 @@
                               listener: handleEndingBinaryExpression(.)
                             listener: endBinaryExpression(+)
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseLiteralNull(&)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -747,9 +747,9 @@
                                     listener: handleSend(hashCode, +)
                               listener: handleEndingBinaryExpression(.)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -815,9 +815,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -828,9 +828,9 @@
                                   listener: handleNoArguments(and)
                                 listener: handleSend(x, and)
                         rewriter()
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
                                   isNextIdentifier(&)
@@ -840,9 +840,9 @@
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
                                   isNextIdentifier(&)
@@ -912,9 +912,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -925,9 +925,9 @@
                                   listener: handleNoArguments(&)
                                 listener: handleSend(x, &)
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
                                   isNextIdentifier(&)
@@ -1002,9 +1002,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1015,9 +1015,9 @@
                                       listener: handleNoArguments(and)
                                     listener: handleSend(x, and)
                             rewriter()
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
@@ -1027,9 +1027,9 @@
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                             rewriter()
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
@@ -1106,9 +1106,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1119,9 +1119,9 @@
                                       listener: handleNoArguments(&)
                                     listener: handleSend(x, &)
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
@@ -1211,9 +1211,9 @@
                             parseVariableInitializerOpt(z)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1224,9 +1224,9 @@
                                             listener: handleNoArguments(and)
                                           listener: handleSend(x, and)
                                   rewriter()
-                                  parsePrecedenceExpression(&, 12, true)
-                                    parseUnaryExpression(&, true)
-                                      parsePrimary(&, expression)
+                                  parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                      parsePrimary(&, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
                                             isNextIdentifier(&)
@@ -1236,9 +1236,9 @@
                                     listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                                   rewriter()
                                   listener: beginBinaryExpression(&)
-                                  parsePrecedenceExpression(&, 12, true)
-                                    parseUnaryExpression(&, true)
-                                      parsePrimary(&, expression)
+                                  parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                      parsePrimary(&, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
                                             isNextIdentifier(&)
@@ -1259,9 +1259,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1350,9 +1350,9 @@
                             parseVariableInitializerOpt(z)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1363,9 +1363,9 @@
                                             listener: handleNoArguments(&)
                                           listener: handleSend(x, &)
                                   listener: beginBinaryExpression(&)
-                                  parsePrecedenceExpression(&, 12, true)
-                                    parseUnaryExpression(&, true)
-                                      parsePrimary(&, expression)
+                                  parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                      parsePrimary(&, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
                                             isNextIdentifier(&)
@@ -1386,9 +1386,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1459,15 +1459,15 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -1481,25 +1481,25 @@
                           rewriter()
                         listener: endBinaryExpression(+)
                         rewriter()
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
                                   isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                   parseArgumentsOpt(y)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
                                   isNextIdentifier(&)
@@ -1510,9 +1510,9 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -1576,15 +1576,15 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -1596,9 +1596,9 @@
                                   listener: handleSend(x, &)
                         listener: endBinaryExpression(+)
                         listener: beginBinaryExpression(&)
-                        parsePrecedenceExpression(&, 12, true)
-                          parseUnaryExpression(&, true)
-                            parsePrimary(&, expression)
+                        parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&, true, ConstantPatternContext.none)
+                            parsePrimary(&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
                                   isNextIdentifier(&)
@@ -1609,9 +1609,9 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -1680,15 +1680,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -1702,25 +1702,25 @@
                               rewriter()
                             listener: endBinaryExpression(+)
                             rewriter()
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                       parseArgumentsOpt(y)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                             reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                             rewriter()
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
@@ -1731,9 +1731,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -1804,15 +1804,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -1824,9 +1824,9 @@
                                       listener: handleSend(x, &)
                             listener: endBinaryExpression(+)
                             listener: beginBinaryExpression(&)
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
@@ -1837,9 +1837,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -1910,9 +1910,9 @@
                         looksLikeLocalFunction(s)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -1925,9 +1925,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -1938,9 +1938,9 @@
                                                           listener: handleNoArguments(and)
                                                         listener: handleSend(x, and)
                                                 rewriter()
-                                                parsePrecedenceExpression(&, 12, true)
-                                                  parseUnaryExpression(&, true)
-                                                    parsePrimary(&, expression)
+                                                parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                    parsePrimary(&, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
                                                           isNextIdentifier(&)
@@ -1950,9 +1950,9 @@
                                                   listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                                                 rewriter()
                                                 listener: beginBinaryExpression(&)
-                                                parsePrecedenceExpression(&, 12, true)
-                                                  parseUnaryExpression(&, true)
-                                                    parsePrimary(&, expression)
+                                                parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                    parsePrimary(&, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
                                                           isNextIdentifier(&)
@@ -1964,9 +1964,9 @@
                                                           listener: handleSend(y, ,)
                                                 listener: endBinaryExpression(&)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
                                                         isNextIdentifier(,)
@@ -1977,9 +1977,9 @@
                                                           listener: handleNoArguments(and)
                                                         listener: handleSend(x, and)
                                                 rewriter()
-                                                parsePrecedenceExpression(&, 12, true)
-                                                  parseUnaryExpression(&, true)
-                                                    parsePrimary(&, expression)
+                                                parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                    parsePrimary(&, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
                                                           isNextIdentifier(&)
@@ -1989,9 +1989,9 @@
                                                   listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                                                 rewriter()
                                                 listener: beginBinaryExpression(&)
-                                                parsePrecedenceExpression(&, 12, true)
-                                                  parseUnaryExpression(&, true)
-                                                    parsePrimary(&, expression)
+                                                parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                    parsePrimary(&, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
                                                           isNextIdentifier(&)
@@ -2013,9 +2013,9 @@
                         looksLikeLocalFunction(s)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(;, expression)
@@ -2028,9 +2028,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -2041,9 +2041,9 @@
                                                           listener: handleNoArguments(&)
                                                         listener: handleSend(x, &)
                                                 listener: beginBinaryExpression(&)
-                                                parsePrecedenceExpression(&, 12, true)
-                                                  parseUnaryExpression(&, true)
-                                                    parsePrimary(&, expression)
+                                                parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                    parsePrimary(&, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
                                                           isNextIdentifier(&)
@@ -2055,9 +2055,9 @@
                                                           listener: handleSend(y, ,)
                                                 listener: endBinaryExpression(&)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
                                                         isNextIdentifier(,)
@@ -2068,9 +2068,9 @@
                                                           listener: handleNoArguments(&)
                                                         listener: handleSend(x, &)
                                                 listener: beginBinaryExpression(&)
-                                                parsePrecedenceExpression(&, 12, true)
-                                                  parseUnaryExpression(&, true)
-                                                    parsePrimary(&, expression)
+                                                parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                    parsePrimary(&, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
                                                           isNextIdentifier(&)
@@ -2140,9 +2140,9 @@
                       listener: beginInitializer(foo)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -2152,9 +2152,9 @@
                                     parseArgumentsOpt(foo)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(foo, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2165,9 +2165,9 @@
                                         listener: handleNoArguments(and)
                                       listener: handleSend(x, and)
                               rewriter()
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)
@@ -2177,9 +2177,9 @@
                                 listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                               rewriter()
                               listener: beginBinaryExpression(&)
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)
@@ -2196,9 +2196,9 @@
                       listener: beginInitializer(bar)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -2208,9 +2208,9 @@
                                     parseArgumentsOpt(bar)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bar, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2221,9 +2221,9 @@
                                         listener: handleNoArguments(and)
                                       listener: handleSend(x, and)
                               rewriter()
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)
@@ -2233,9 +2233,9 @@
                                 listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                               rewriter()
                               listener: beginBinaryExpression(&)
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)
@@ -2262,9 +2262,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -2277,16 +2277,16 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello )
                                                         parseExpression(${)
-                                                          parsePrecedenceExpression(${, 1, true)
-                                                            parseUnaryExpression(${, true)
-                                                              parsePrimary(${, expression)
+                                                          parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                              parsePrimary(${, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
                                                                     isNextIdentifier(${)
@@ -2297,9 +2297,9 @@
                                                                       listener: handleNoArguments(and)
                                                                     listener: handleSend(x, and)
                                                             rewriter()
-                                                            parsePrecedenceExpression(&, 12, true)
-                                                              parseUnaryExpression(&, true)
-                                                                parsePrimary(&, expression)
+                                                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                                parsePrimary(&, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(&, expression)
                                                                     parseSend(&, expression)
                                                                       isNextIdentifier(&)
@@ -2309,9 +2309,9 @@
                                                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}], and, and)
                                                             rewriter()
                                                             listener: beginBinaryExpression(&)
-                                                            parsePrecedenceExpression(&, 12, true)
-                                                              parseUnaryExpression(&, true)
-                                                                parsePrimary(&, expression)
+                                                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                                parsePrimary(&, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(&, expression)
                                                                     parseSend(&, expression)
                                                                       isNextIdentifier(&)
@@ -2385,9 +2385,9 @@
                       listener: beginInitializer(foo)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -2397,9 +2397,9 @@
                                     parseArgumentsOpt(foo)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(foo, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2410,9 +2410,9 @@
                                         listener: handleNoArguments(&)
                                       listener: handleSend(x, &)
                               listener: beginBinaryExpression(&)
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)
@@ -2429,9 +2429,9 @@
                       listener: beginInitializer(bar)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -2441,9 +2441,9 @@
                                     parseArgumentsOpt(bar)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bar, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2454,9 +2454,9 @@
                                         listener: handleNoArguments(&)
                                       listener: handleSend(x, &)
                               listener: beginBinaryExpression(&)
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)
@@ -2483,9 +2483,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -2498,16 +2498,16 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello )
                                                         parseExpression(${)
-                                                          parsePrecedenceExpression(${, 1, true)
-                                                            parseUnaryExpression(${, true)
-                                                              parsePrimary(${, expression)
+                                                          parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                              parsePrimary(${, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
                                                                     isNextIdentifier(${)
@@ -2518,9 +2518,9 @@
                                                                       listener: handleNoArguments(&)
                                                                     listener: handleSend(x, &)
                                                             listener: beginBinaryExpression(&)
-                                                            parsePrecedenceExpression(&, 12, true)
-                                                              parseUnaryExpression(&, true)
-                                                                parsePrimary(&, expression)
+                                                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                                                parsePrimary(&, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(&, expression)
                                                                     parseSend(&, expression)
                                                                       isNextIdentifier(&)
@@ -2626,9 +2626,9 @@
                         looksLikeLocalFunction(y)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2647,9 +2647,9 @@
                         looksLikeLocalFunction(x)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2660,9 +2660,9 @@
                                         listener: handleNoArguments(&)
                                       listener: handleSend(x, &)
                               listener: beginBinaryExpression(&)
-                              parsePrecedenceExpression(&, 12, true)
-                                parseUnaryExpression(&, true)
-                                  parsePrimary(&, expression)
+                              parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                  parsePrimary(&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
                                         isNextIdentifier(&)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
index 8f4e31d..430580c 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 parseFunctionBody(a, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -64,7 +64,7 @@
                                 parseArgumentsOpt(runtimeType)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(runtimeType, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -76,11 +76,11 @@
                               listener: handleSend(hashCode, or)
                         listener: handleEndingBinaryExpression(.)
                         rewriter()
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseLiteralNull(|)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -90,12 +90,12 @@
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseLiteralNull(|)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -139,9 +139,9 @@
                 parseFunctionBody(b, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -151,7 +151,7 @@
                                 parseArgumentsOpt(runtimeType)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(runtimeType, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -163,12 +163,12 @@
                               listener: handleSend(hashCode, |)
                         listener: handleEndingBinaryExpression(.)
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseLiteralNull(|)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -217,9 +217,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -229,7 +229,7 @@
                                     parseArgumentsOpt(runtimeType)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(runtimeType, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -241,11 +241,11 @@
                                   listener: handleSend(hashCode, or)
                             listener: handleEndingBinaryExpression(.)
                             rewriter()
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseLiteralNull(|)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -255,12 +255,12 @@
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                             rewriter()
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseLiteralNull(|)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -311,9 +311,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -323,7 +323,7 @@
                                     parseArgumentsOpt(runtimeType)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(runtimeType, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -335,12 +335,12 @@
                                   listener: handleSend(hashCode, |)
                             listener: handleEndingBinaryExpression(.)
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseLiteralNull(|)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -386,15 +386,15 @@
                 parseFunctionBody(e, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -404,7 +404,7 @@
                                   parseArgumentsOpt(runtimeType)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(runtimeType, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -419,30 +419,30 @@
                           rewriter()
                         listener: endBinaryExpression(+)
                         rewriter()
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseLiteralNull(|)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseLiteralNull(|)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -454,9 +454,9 @@
                                 listener: handleSend(hashCode, +)
                           listener: handleEndingBinaryExpression(.)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -493,15 +493,15 @@
                 parseFunctionBody(f, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -511,7 +511,7 @@
                                   parseArgumentsOpt(runtimeType)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(runtimeType, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -524,12 +524,12 @@
                           listener: handleEndingBinaryExpression(.)
                         listener: endBinaryExpression(+)
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseLiteralNull(|)
                                 listener: handleLiteralNull(null)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -541,9 +541,9 @@
                                 listener: handleSend(hashCode, +)
                           listener: handleEndingBinaryExpression(.)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -585,15 +585,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -603,7 +603,7 @@
                                       parseArgumentsOpt(runtimeType)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(runtimeType, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -618,30 +618,30 @@
                               rewriter()
                             listener: endBinaryExpression(+)
                             rewriter()
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseLiteralNull(|)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                             reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                             rewriter()
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseLiteralNull(|)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -653,9 +653,9 @@
                                     listener: handleSend(hashCode, +)
                               listener: handleEndingBinaryExpression(.)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -699,15 +699,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -717,7 +717,7 @@
                                       parseArgumentsOpt(runtimeType)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(runtimeType, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -730,12 +730,12 @@
                               listener: handleEndingBinaryExpression(.)
                             listener: endBinaryExpression(+)
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseLiteralNull(|)
                                     listener: handleLiteralNull(null)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -747,9 +747,9 @@
                                     listener: handleSend(hashCode, +)
                               listener: handleEndingBinaryExpression(.)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -815,9 +815,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -828,9 +828,9 @@
                                   listener: handleNoArguments(or)
                                 listener: handleSend(x, or)
                         rewriter()
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
                                   isNextIdentifier(|)
@@ -840,9 +840,9 @@
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
                                   isNextIdentifier(|)
@@ -912,9 +912,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -925,9 +925,9 @@
                                   listener: handleNoArguments(|)
                                 listener: handleSend(x, |)
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
                                   isNextIdentifier(|)
@@ -1002,9 +1002,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1015,9 +1015,9 @@
                                       listener: handleNoArguments(or)
                                     listener: handleSend(x, or)
                             rewriter()
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
@@ -1027,9 +1027,9 @@
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                             rewriter()
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
@@ -1106,9 +1106,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1119,9 +1119,9 @@
                                       listener: handleNoArguments(|)
                                     listener: handleSend(x, |)
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
@@ -1211,9 +1211,9 @@
                             parseVariableInitializerOpt(z)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1224,9 +1224,9 @@
                                             listener: handleNoArguments(or)
                                           listener: handleSend(x, or)
                                   rewriter()
-                                  parsePrecedenceExpression(|, 10, true)
-                                    parseUnaryExpression(|, true)
-                                      parsePrimary(|, expression)
+                                  parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                      parsePrimary(|, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
                                             isNextIdentifier(|)
@@ -1236,9 +1236,9 @@
                                     listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                                   rewriter()
                                   listener: beginBinaryExpression(|)
-                                  parsePrecedenceExpression(|, 10, true)
-                                    parseUnaryExpression(|, true)
-                                      parsePrimary(|, expression)
+                                  parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                      parsePrimary(|, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
                                             isNextIdentifier(|)
@@ -1259,9 +1259,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1350,9 +1350,9 @@
                             parseVariableInitializerOpt(z)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1363,9 +1363,9 @@
                                             listener: handleNoArguments(|)
                                           listener: handleSend(x, |)
                                   listener: beginBinaryExpression(|)
-                                  parsePrecedenceExpression(|, 10, true)
-                                    parseUnaryExpression(|, true)
-                                      parsePrimary(|, expression)
+                                  parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                      parsePrimary(|, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
                                             isNextIdentifier(|)
@@ -1386,9 +1386,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -1459,15 +1459,15 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -1481,25 +1481,25 @@
                           rewriter()
                         listener: endBinaryExpression(+)
                         rewriter()
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
                                   isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                   parseArgumentsOpt(y)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
                                   isNextIdentifier(|)
@@ -1510,9 +1510,9 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -1576,15 +1576,15 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
                                   isNextIdentifier(+)
@@ -1596,9 +1596,9 @@
                                   listener: handleSend(x, |)
                         listener: endBinaryExpression(+)
                         listener: beginBinaryExpression(|)
-                        parsePrecedenceExpression(|, 10, true)
-                          parseUnaryExpression(|, true)
-                            parsePrimary(|, expression)
+                        parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                          parseUnaryExpression(|, true, ConstantPatternContext.none)
+                            parsePrimary(|, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
                                   isNextIdentifier(|)
@@ -1609,9 +1609,9 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
                                 parseLiteralInt(+)
                                   listener: handleLiteralInt(3)
                           listener: endBinaryExpression(+)
@@ -1680,15 +1680,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -1702,25 +1702,25 @@
                               rewriter()
                             listener: endBinaryExpression(+)
                             rewriter()
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                       parseArgumentsOpt(y)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                             reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                             rewriter()
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
@@ -1731,9 +1731,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -1804,15 +1804,15 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(1)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
                                       isNextIdentifier(+)
@@ -1824,9 +1824,9 @@
                                       listener: handleSend(x, |)
                             listener: endBinaryExpression(+)
                             listener: beginBinaryExpression(|)
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
@@ -1837,9 +1837,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(3)
                               listener: endBinaryExpression(+)
@@ -1910,9 +1910,9 @@
                         looksLikeLocalFunction(s)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -1925,9 +1925,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -1938,9 +1938,9 @@
                                                           listener: handleNoArguments(or)
                                                         listener: handleSend(x, or)
                                                 rewriter()
-                                                parsePrecedenceExpression(|, 10, true)
-                                                  parseUnaryExpression(|, true)
-                                                    parsePrimary(|, expression)
+                                                parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                    parsePrimary(|, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
                                                           isNextIdentifier(|)
@@ -1950,9 +1950,9 @@
                                                   listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                                                 rewriter()
                                                 listener: beginBinaryExpression(|)
-                                                parsePrecedenceExpression(|, 10, true)
-                                                  parseUnaryExpression(|, true)
-                                                    parsePrimary(|, expression)
+                                                parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                    parsePrimary(|, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
                                                           isNextIdentifier(|)
@@ -1964,9 +1964,9 @@
                                                           listener: handleSend(y, ,)
                                                 listener: endBinaryExpression(|)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
                                                         isNextIdentifier(,)
@@ -1977,9 +1977,9 @@
                                                           listener: handleNoArguments(or)
                                                         listener: handleSend(x, or)
                                                 rewriter()
-                                                parsePrecedenceExpression(|, 10, true)
-                                                  parseUnaryExpression(|, true)
-                                                    parsePrimary(|, expression)
+                                                parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                    parsePrimary(|, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
                                                           isNextIdentifier(|)
@@ -1989,9 +1989,9 @@
                                                   listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                                                 rewriter()
                                                 listener: beginBinaryExpression(|)
-                                                parsePrecedenceExpression(|, 10, true)
-                                                  parseUnaryExpression(|, true)
-                                                    parsePrimary(|, expression)
+                                                parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                    parsePrimary(|, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
                                                           isNextIdentifier(|)
@@ -2013,9 +2013,9 @@
                         looksLikeLocalFunction(s)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(;, expression)
@@ -2028,9 +2028,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -2041,9 +2041,9 @@
                                                           listener: handleNoArguments(|)
                                                         listener: handleSend(x, |)
                                                 listener: beginBinaryExpression(|)
-                                                parsePrecedenceExpression(|, 10, true)
-                                                  parseUnaryExpression(|, true)
-                                                    parsePrimary(|, expression)
+                                                parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                    parsePrimary(|, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
                                                           isNextIdentifier(|)
@@ -2055,9 +2055,9 @@
                                                           listener: handleSend(y, ,)
                                                 listener: endBinaryExpression(|)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
                                                         isNextIdentifier(,)
@@ -2068,9 +2068,9 @@
                                                           listener: handleNoArguments(|)
                                                         listener: handleSend(x, |)
                                                 listener: beginBinaryExpression(|)
-                                                parsePrecedenceExpression(|, 10, true)
-                                                  parseUnaryExpression(|, true)
-                                                    parsePrimary(|, expression)
+                                                parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                    parsePrimary(|, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
                                                           isNextIdentifier(|)
@@ -2140,9 +2140,9 @@
                       listener: beginInitializer(foo)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -2152,9 +2152,9 @@
                                     parseArgumentsOpt(foo)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(foo, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2165,9 +2165,9 @@
                                         listener: handleNoArguments(or)
                                       listener: handleSend(x, or)
                               rewriter()
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)
@@ -2177,9 +2177,9 @@
                                 listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                               rewriter()
                               listener: beginBinaryExpression(|)
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)
@@ -2196,9 +2196,9 @@
                       listener: beginInitializer(bar)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -2208,9 +2208,9 @@
                                     parseArgumentsOpt(bar)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bar, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2221,9 +2221,9 @@
                                         listener: handleNoArguments(or)
                                       listener: handleSend(x, or)
                               rewriter()
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)
@@ -2233,9 +2233,9 @@
                                 listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                               rewriter()
                               listener: beginBinaryExpression(|)
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)
@@ -2262,9 +2262,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -2277,16 +2277,16 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello )
                                                         parseExpression(${)
-                                                          parsePrecedenceExpression(${, 1, true)
-                                                            parseUnaryExpression(${, true)
-                                                              parsePrimary(${, expression)
+                                                          parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                              parsePrimary(${, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
                                                                     isNextIdentifier(${)
@@ -2297,9 +2297,9 @@
                                                                       listener: handleNoArguments(or)
                                                                     listener: handleSend(x, or)
                                                             rewriter()
-                                                            parsePrecedenceExpression(|, 10, true)
-                                                              parseUnaryExpression(|, true)
-                                                                parsePrimary(|, expression)
+                                                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                                parsePrimary(|, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(|, expression)
                                                                     parseSend(|, expression)
                                                                       isNextIdentifier(|)
@@ -2309,9 +2309,9 @@
                                                               listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
                                                             rewriter()
                                                             listener: beginBinaryExpression(|)
-                                                            parsePrecedenceExpression(|, 10, true)
-                                                              parseUnaryExpression(|, true)
-                                                                parsePrimary(|, expression)
+                                                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                                parsePrimary(|, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(|, expression)
                                                                     parseSend(|, expression)
                                                                       isNextIdentifier(|)
@@ -2385,9 +2385,9 @@
                       listener: beginInitializer(foo)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -2397,9 +2397,9 @@
                                     parseArgumentsOpt(foo)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(foo, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2410,9 +2410,9 @@
                                         listener: handleNoArguments(|)
                                       listener: handleSend(x, |)
                               listener: beginBinaryExpression(|)
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)
@@ -2429,9 +2429,9 @@
                       listener: beginInitializer(bar)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -2441,9 +2441,9 @@
                                     parseArgumentsOpt(bar)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(bar, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -2454,9 +2454,9 @@
                                         listener: handleNoArguments(|)
                                       listener: handleSend(x, |)
                               listener: beginBinaryExpression(|)
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)
@@ -2483,9 +2483,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -2498,16 +2498,16 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello )
                                                         parseExpression(${)
-                                                          parsePrecedenceExpression(${, 1, true)
-                                                            parseUnaryExpression(${, true)
-                                                              parsePrimary(${, expression)
+                                                          parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                              parsePrimary(${, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
                                                                     isNextIdentifier(${)
@@ -2518,9 +2518,9 @@
                                                                       listener: handleNoArguments(|)
                                                                     listener: handleSend(x, |)
                                                             listener: beginBinaryExpression(|)
-                                                            parsePrecedenceExpression(|, 10, true)
-                                                              parseUnaryExpression(|, true)
-                                                                parsePrimary(|, expression)
+                                                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                                                parsePrimary(|, expression, ConstantPatternContext.none)
                                                                   parseSendOrFunctionLiteral(|, expression)
                                                                     parseSend(|, expression)
                                                                       isNextIdentifier(|)
@@ -2626,9 +2626,9 @@
                         looksLikeLocalFunction(y)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2647,9 +2647,9 @@
                         looksLikeLocalFunction(x)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2660,9 +2660,9 @@
                                         listener: handleNoArguments(|)
                                       listener: handleSend(x, |)
                               listener: beginBinaryExpression(|)
-                              parsePrecedenceExpression(|, 10, true)
-                                parseUnaryExpression(|, true)
-                                  parsePrimary(|, expression)
+                              parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                  parsePrimary(|, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
                                         isNextIdentifier(|)

pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect
index 57cb219..902dad1 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(m)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(})
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -61,9 +61,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(T, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 looksLikeFunctionBody(>)
                                                 parseSend(<, expression)
@@ -76,9 +76,9 @@
                                                       parseArgumentsRest(()
                                                         listener: beginArguments(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralListSetMapOrFunction((, null)
                                                                   listener: beginTypeArguments(<)
                                                                   listener: handleIdentifier(Z, typeReference)

pkg/front_end/parser_testcases/error_recovery/issue_39058.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_39058.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_39058.crash_dart.intertwined.expect
index 584fcc0..093d144 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_39058.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_39058.crash_dart.intertwined.expect
@@ -22,9 +22,9 @@
                   looksLikeLocalFunction(<)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             parseLiteralListSetMapOrFunction({, null)
                               listener: beginTypeArguments(<)
                               reportRecoverableErrorWithToken([], Instance of 'Template<(Token) => Message>')

pkg/front_end/parser_testcases/error_recovery/issue_39058_prime.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_39058_prime.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_39058_prime.crash_dart.intertwined.expect
index 5b3514d..c8289d0 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_39058_prime.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_39058_prime.crash_dart.intertwined.expect
@@ -22,9 +22,9 @@
                   looksLikeLocalFunction(<)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             parseLiteralListSetMapOrFunction({, null)
                               listener: beginTypeArguments(<)
                               reportRecoverableErrorWithToken([], Instance of 'Template<(Token) => Message>')

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_39060.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_39060.dart.intertwined.expect
index d28fdff..188e43b 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_39060.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_39060.dart.intertwined.expect
@@ -64,9 +64,9 @@
                         looksLikeLocalFunction(<)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseLiteralListSetMapOrFunction(;, null)
                                     listener: beginTypeArguments(<)
                                     reportRecoverableErrorWithToken(}, Instance of 'Template<(Token) => Message>')

pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect
index 4d9d1a5..3d68cba 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect
@@ -52,9 +52,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
                         isNextIdentifier(=>)

pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.intertwined.expect
index e09df17..bee248c 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_39230.crash_dart.intertwined.expect
@@ -95,9 +95,9 @@
                           parseSuperInitializerExpression(:)
                             parseInitializerExpressionRest(:)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseSuperExpression(:, expression)
                                         listener: handleSuperExpression(super, expression)
                                         listener: handleNoTypeArguments(()

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

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 ab72ecb..3e58885 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
@@ -32,9 +32,9 @@
                 looksLikeLocalFunction(builder)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -57,9 +57,9 @@
                         listener: handleEndingBinaryExpression(..)
                         parseArgumentOrIndexStar(foo, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)
@@ -81,9 +81,9 @@
                 looksLikeLocalFunction(FilterSet)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -96,10 +96,10 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -124,9 +124,9 @@
                                                   parseFunctionBody(), true, false)
                                                     parseExpressionFunctionBody(=>, true)
                                                       parseExpression(=>)
-                                                        parsePrecedenceExpression(=>, 1, true)
-                                                          parseUnaryExpression(=>, true)
-                                                            parsePrimary(=>, expression)
+                                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral(=>, expression)
                                                                 parseSend(=>, expression)
                                                                   isNextIdentifier(=>)
@@ -149,9 +149,9 @@
                                                             listener: handleEndingBinaryExpression(..)
                                                             parseArgumentOrIndexStar(foo, Instance of 'NoTypeParamOrArg', false)
                                                               parseExpression([)
-                                                                parsePrecedenceExpression([, 1, true)
-                                                                  parseUnaryExpression([, true)
-                                                                    parsePrimary([, expression)
+                                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                                       parseSendOrFunctionLiteral([, expression)
                                                                         parseSend([, expression)
                                                                           isNextIdentifier([)
@@ -178,9 +178,9 @@
                 looksLikeLocalFunction(builder)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -206,9 +206,9 @@
                           rewriter()
                         parseArgumentOrIndexStar(foo, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSend([, expression)
                                     isNextIdentifier([)
                                     ensureIdentifier([, expression)
@@ -232,9 +232,9 @@
                 looksLikeLocalFunction(FilterSet)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -247,10 +247,10 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -275,9 +275,9 @@
                                                   parseFunctionBody(), true, false)
                                                     parseExpressionFunctionBody(=>, true)
                                                       parseExpression(=>)
-                                                        parsePrecedenceExpression(=>, 1, true)
-                                                          parseUnaryExpression(=>, true)
-                                                            parsePrimary(=>, expression)
+                                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral(=>, expression)
                                                                 parseSend(=>, expression)
                                                                   isNextIdentifier(=>)
@@ -303,9 +303,9 @@
                                                               rewriter()
                                                             parseArgumentOrIndexStar(foo, Instance of 'NoTypeParamOrArg', false)
                                                               parseExpression([)
-                                                                parsePrecedenceExpression([, 1, true)
-                                                                  parseUnaryExpression([, true)
-                                                                    parsePrimary([, expression)
+                                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                                       parseSend([, expression)
                                                                         isNextIdentifier([)
                                                                         ensureIdentifier([, expression)
@@ -334,9 +334,9 @@
                 looksLikeLocalFunction(builder)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -359,9 +359,9 @@
                         listener: handleEndingBinaryExpression(..)
                         parseArgumentOrIndexStar(foo, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSend([, expression)
                                     isNextIdentifier([)
                                     ensureIdentifier([, expression)
@@ -385,9 +385,9 @@
                 looksLikeLocalFunction(FilterSet)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -400,10 +400,10 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -428,9 +428,9 @@
                                                   parseFunctionBody(), true, false)
                                                     parseExpressionFunctionBody(=>, true)
                                                       parseExpression(=>)
-                                                        parsePrecedenceExpression(=>, 1, true)
-                                                          parseUnaryExpression(=>, true)
-                                                            parsePrimary(=>, expression)
+                                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral(=>, expression)
                                                                 parseSend(=>, expression)
                                                                   isNextIdentifier(=>)
@@ -453,9 +453,9 @@
                                                             listener: handleEndingBinaryExpression(..)
                                                             parseArgumentOrIndexStar(foo, Instance of 'NoTypeParamOrArg', false)
                                                               parseExpression([)
-                                                                parsePrecedenceExpression([, 1, true)
-                                                                  parseUnaryExpression([, true)
-                                                                    parsePrimary([, expression)
+                                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                                       parseSend([, expression)
                                                                         isNextIdentifier([)
                                                                         ensureIdentifier([, expression)

pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect
index 8c20797..fbee2a3 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect
@@ -58,9 +58,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                           rewriter()
-                          parsePrecedenceExpression(|, 10, true)
-                            parseUnaryExpression(|, true)
-                              parsePrimary(|, expression)
+                          parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                            parseUnaryExpression(|, true, ConstantPatternContext.none)
+                              parsePrimary(|, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(|, expression)
                                   parseSend(|, expression)
                                     isNextIdentifier(|)
@@ -88,25 +88,25 @@
                           rewriter()
                         listener: endBinaryExpression(==)
                         rewriter()
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(b)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -117,9 +117,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -138,9 +138,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -213,9 +213,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -226,15 +226,15 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                           rewriter()
-                          parsePrecedenceExpression(&, 12, true)
-                            parseUnaryExpression(&, true)
-                              parsePrimary(&, expression)
+                          parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                            parseUnaryExpression(&, true, ConstantPatternContext.none)
+                              parsePrimary(&, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(&, expression)
                                   parseSend(&, expression)
                                     isNextIdentifier(&)
@@ -243,25 +243,25 @@
                           rewriter()
                         listener: endBinaryExpression(==)
                         rewriter()
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(b)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -272,9 +272,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -293,9 +293,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)

pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect
index c68db59..8103443 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect
@@ -58,9 +58,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                           rewriter()
-                          parsePrecedenceExpression(|, 10, true)
-                            parseUnaryExpression(|, true)
-                              parsePrimary(|, expression)
+                          parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                            parseUnaryExpression(|, true, ConstantPatternContext.none)
+                              parsePrimary(|, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(|, expression)
                                   parseSend(|, expression)
                                     isNextIdentifier(|)
@@ -88,25 +88,25 @@
                           rewriter()
                         listener: endBinaryExpression(==)
                         rewriter()
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(b)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -117,9 +117,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -138,9 +138,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -222,9 +222,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -235,15 +235,15 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                           rewriter()
-                          parsePrecedenceExpression(|, 10, true)
-                            parseUnaryExpression(|, true)
-                              parsePrimary(|, expression)
+                          parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                            parseUnaryExpression(|, true, ConstantPatternContext.none)
+                              parsePrimary(|, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(|, expression)
                                   parseSend(|, expression)
                                     isNextIdentifier(|)
@@ -252,25 +252,25 @@
                           rewriter()
                         listener: endBinaryExpression(==)
                         rewriter()
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(b)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -281,15 +281,15 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                             rewriter()
-                            parsePrecedenceExpression(|, 10, true)
-                              parseUnaryExpression(|, true)
-                                parsePrimary(|, expression)
+                            parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                              parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                parsePrimary(|, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
                                       isNextIdentifier(|)
@@ -300,25 +300,25 @@
                           rewriter()
                         listener: endBinaryExpression(||)
                         rewriter()
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(c)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '||' instead of the written out word., Try replacing 'or' with '||'., {string: or, string2: ||}], or, or)
                         rewriter()
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -329,9 +329,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(c, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -350,9 +350,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -422,9 +422,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -435,15 +435,15 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                           rewriter()
-                          parsePrecedenceExpression(&, 12, true)
-                            parseUnaryExpression(&, true)
-                              parsePrimary(&, expression)
+                          parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                            parseUnaryExpression(&, true, ConstantPatternContext.none)
+                              parsePrimary(&, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(&, expression)
                                   parseSend(&, expression)
                                     isNextIdentifier(&)
@@ -452,25 +452,25 @@
                           rewriter()
                         listener: endBinaryExpression(==)
                         rewriter()
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(b)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -481,9 +481,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -502,9 +502,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -586,9 +586,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -599,15 +599,15 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                           rewriter()
-                          parsePrecedenceExpression(&, 12, true)
-                            parseUnaryExpression(&, true)
-                              parsePrimary(&, expression)
+                          parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                            parseUnaryExpression(&, true, ConstantPatternContext.none)
+                              parsePrimary(&, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(&, expression)
                                   parseSend(&, expression)
                                     isNextIdentifier(&)
@@ -616,25 +616,25 @@
                           rewriter()
                         listener: endBinaryExpression(==)
                         rewriter()
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(b)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -645,15 +645,15 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                             rewriter()
-                            parsePrecedenceExpression(&, 12, true)
-                              parseUnaryExpression(&, true)
-                                parsePrimary(&, expression)
+                            parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                              parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                parsePrimary(&, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
                                       isNextIdentifier(&)
@@ -664,25 +664,25 @@
                           rewriter()
                         listener: endBinaryExpression(&&)
                         rewriter()
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(c)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}])
                           listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&&' instead of the written out word., Try replacing 'and' with '&&'., {string: and, string2: &&}], and, and)
                         rewriter()
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -693,9 +693,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(c, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -714,9 +714,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)

pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect
index 244a9e6..6cbc7fe 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect
@@ -58,9 +58,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,16 +71,16 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                         listener: endBinaryExpression(==)
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -91,9 +91,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -112,9 +112,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -196,9 +196,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -209,16 +209,16 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                         listener: endBinaryExpression(==)
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -229,17 +229,17 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
                         listener: endBinaryExpression(||)
                         listener: beginBinaryExpression(||)
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
                                   isNextIdentifier(||)
@@ -250,9 +250,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(c, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -271,9 +271,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -343,9 +343,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -356,16 +356,16 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                         listener: endBinaryExpression(==)
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -376,9 +376,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -397,9 +397,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)
@@ -481,9 +481,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -494,16 +494,16 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(a, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralNull(==)
                                 listener: handleLiteralNull(null)
                         listener: endBinaryExpression(==)
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -514,17 +514,17 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(b, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
                         listener: endBinaryExpression(&&)
                         listener: beginBinaryExpression(&&)
-                        parsePrecedenceExpression(&&, 7, true)
-                          parseUnaryExpression(&&, true)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                          parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                            parsePrimary(&&, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
                                   isNextIdentifier(&&)
@@ -535,9 +535,9 @@
                                     listener: handleNoArguments(==)
                                   listener: handleSend(c, ==)
                           listener: beginBinaryExpression(==)
-                          parsePrecedenceExpression(==, 8, true)
-                            parseUnaryExpression(==, true)
-                              parsePrimary(==, expression)
+                          parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                            parseUnaryExpression(==, true, ConstantPatternContext.none)
+                              parsePrimary(==, expression, ConstantPatternContext.none)
                                 parseLiteralNull(==)
                                   listener: handleLiteralNull(null)
                           listener: endBinaryExpression(==)
@@ -556,9 +556,9 @@
                           parseReturnStatement({)
                             listener: beginReturnStatement(return)
                             parseExpression(return)
-                              parsePrecedenceExpression(return, 1, true)
-                                parseUnaryExpression(return, true)
-                                  parsePrimary(return, expression)
+                              parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                  parsePrimary(return, expression, ConstantPatternContext.none)
                                     parseLiteralNull(return)
                                       listener: handleLiteralNull(null)
                             ensureSemicolon(null)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect
index 9f487f0..e1b4647 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect
@@ -49,15 +49,15 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
-                              parsePrimary(Map, expression)
+                              parsePrimary(Map, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(Map, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(String, typeReference)
@@ -100,9 +100,9 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralListSetMapOrFunction(=, null)
                             listener: beginTypeArguments(<)
                             listener: handleIdentifier(String, typeReference)
@@ -145,15 +145,15 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
-                              parsePrimary(Map, expression)
+                              parsePrimary(Map, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments({)
                                 parseLiteralSetOrMapSuffix(Map, null)
                                   listener: handleLiteralSetOrMap(0, {, null, }, false)
@@ -184,9 +184,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -238,9 +238,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -281,15 +281,15 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
-                              parsePrimary(Map, expression)
+                              parsePrimary(Map, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(Map, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(String, typeReference)
@@ -305,17 +305,17 @@
                                   listener: endTypeArguments(2, <, >)
                                   parseLiteralSetOrMapSuffix(>, null)
                                     parseExpression({)
-                                      parsePrecedenceExpression({, 1, true)
-                                        parseUnaryExpression({, true)
-                                          parsePrimary({, expression)
+                                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                                          parsePrimary({, expression, ConstantPatternContext.none)
                                             parseLiteralString({)
                                               parseSingleLiteralString({)
                                                 listener: beginLiteralString("a")
                                                 listener: endLiteralString(0, :)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralNull(:)
                                               listener: handleLiteralNull(null)
                                     listener: handleLiteralMapEntry(:, })
@@ -347,29 +347,29 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
-                              parsePrimary(Map, expression)
+                              parsePrimary(Map, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments({)
                                 parseLiteralSetOrMapSuffix(Map, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralString({)
                                             parseSingleLiteralString({)
                                               listener: beginLiteralString("a")
                                               listener: endLiteralString(0, :)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralNull(:)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralMapEntry(:, })
@@ -401,9 +401,9 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralListSetMapOrFunction(=, null)
                             listener: beginTypeArguments(<)
                             listener: handleIdentifier(String, typeReference)
@@ -419,17 +419,17 @@
                             listener: endTypeArguments(2, <, >)
                             parseLiteralSetOrMapSuffix(>, null)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralString({)
                                         parseSingleLiteralString({)
                                           listener: beginLiteralString("a")
                                           listener: endLiteralString(0, :)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralNull(:)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralMapEntry(:, })
@@ -461,23 +461,23 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           listener: handleNoTypeArguments({)
                           parseLiteralSetOrMapSuffix(=, null)
                             parseExpression({)
-                              parsePrecedenceExpression({, 1, true)
-                                parseUnaryExpression({, true)
-                                  parsePrimary({, expression)
+                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                  parsePrimary({, expression, ConstantPatternContext.none)
                                     parseLiteralString({)
                                       parseSingleLiteralString({)
                                         listener: beginLiteralString("a")
                                         listener: endLiteralString(0, :)
                             parseExpression(:)
-                              parsePrecedenceExpression(:, 1, true)
-                                parseUnaryExpression(:, true)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseLiteralNull(:)
                                       listener: handleLiteralNull(null)
                             listener: handleLiteralMapEntry(:, })

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_const.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_const.dart.intertwined.expect
index 284f6e8..2ff51ab 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_const.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_const.dart.intertwined.expect
@@ -49,9 +49,9 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
@@ -99,9 +99,9 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(<)
                             parseLiteralListSetMapOrFunction(const, const)
@@ -147,9 +147,9 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
@@ -185,9 +185,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
                             parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo')
@@ -241,9 +241,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
                             parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg')
@@ -286,9 +286,9 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
@@ -308,17 +308,17 @@
                               listener: endTypeArguments(2, <, >)
                               parseLiteralSetOrMapSuffix(>, const)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralString({)
                                           parseSingleLiteralString({)
                                             listener: beginLiteralString("a")
                                             listener: endLiteralString(0, :)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralMapEntry(:, })
@@ -351,9 +351,9 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
@@ -361,17 +361,17 @@
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(Map, const)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralString({)
                                         parseSingleLiteralString({)
                                           listener: beginLiteralString("a")
                                           listener: endLiteralString(0, :)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralNull(:)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralMapEntry(:, })
@@ -404,9 +404,9 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(<)
                             parseLiteralListSetMapOrFunction(const, const)
@@ -424,17 +424,17 @@
                               listener: endTypeArguments(2, <, >)
                               parseLiteralSetOrMapSuffix(>, const)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralString({)
                                           parseSingleLiteralString({)
                                             listener: beginLiteralString("a")
                                             listener: endLiteralString(0, :)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralMapEntry(:, })
@@ -467,25 +467,25 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral({)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, const)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralString({)
                                         parseSingleLiteralString({)
                                           listener: beginLiteralString("a")
                                           listener: endLiteralString(0, :)
                               parseExpression(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralNull(:)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralMapEntry(:, })

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect
index e1d9efa..c7b1566 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect
@@ -45,15 +45,15 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
-                              parsePrimary(List, expression)
+                              parsePrimary(List, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(List, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(List, typeReference)
@@ -92,9 +92,9 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralListSetMapOrFunction(=, null)
                             listener: beginTypeArguments(<)
                             listener: handleIdentifier(List, typeReference)
@@ -133,15 +133,15 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
-                              parsePrimary(List, expression)
+                              parsePrimary(List, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([])
                                 parseLiteralListSuffix(List, null)
                                   rewriteSquareBrackets(List)
@@ -171,9 +171,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -218,9 +218,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -257,15 +257,15 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
-                              parsePrimary(List, expression)
+                              parsePrimary(List, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(List, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(List, typeReference)
@@ -278,9 +278,9 @@
                                   listener: endTypeArguments(1, <, >)
                                   parseLiteralListSuffix(>, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralNull([)
                                               listener: handleLiteralNull(null)
                                     listener: handleLiteralList(1, [, null, ])
@@ -307,9 +307,9 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
@@ -321,9 +321,9 @@
                               listener: handleSend(List, [)
                       parseArgumentOrIndexStar(List, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralNull([)
                                   listener: handleLiteralNull(null)
                         listener: handleIndexedExpression(null, [, ])
@@ -350,9 +350,9 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralListSetMapOrFunction(=, null)
                             listener: beginTypeArguments(<)
                             listener: handleIdentifier(List, typeReference)
@@ -365,9 +365,9 @@
                             listener: endTypeArguments(1, <, >)
                             parseLiteralListSuffix(>, null)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralNull([)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralList(1, [, null, ])
@@ -394,15 +394,15 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           listener: handleNoTypeArguments([)
                           parseLiteralListSuffix(=, null)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralNull([)
                                       listener: handleLiteralNull(null)
                             listener: handleLiteralList(1, [, null, ])

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_const.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_const.dart.intertwined.expect
index 4aac064..5c3557d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_const.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_const.dart.intertwined.expect
@@ -45,9 +45,9 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
@@ -91,9 +91,9 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(<)
                             parseLiteralListSetMapOrFunction(const, const)
@@ -135,9 +135,9 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
@@ -172,9 +172,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
                             parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo')
@@ -221,9 +221,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
                             parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg')
@@ -262,9 +262,9 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
@@ -281,9 +281,9 @@
                               listener: endTypeArguments(1, <, >)
                               parseLiteralListSuffix(>, const)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralNull([)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralList(1, [, const, ])
@@ -311,9 +311,9 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
@@ -321,9 +321,9 @@
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(List, const)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralNull([)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralList(1, [, const, ])
@@ -351,9 +351,9 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(<)
                             parseLiteralListSetMapOrFunction(const, const)
@@ -368,9 +368,9 @@
                               listener: endTypeArguments(1, <, >)
                               parseLiteralListSuffix(>, const)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralNull([)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralList(1, [, const, ])
@@ -398,17 +398,17 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral([)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(const, const)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralNull([)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralList(1, [, const, ])

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect
index d8c773d..9488bf5 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect
@@ -45,14 +45,14 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
-                            parsePrimary(List, expression)
+                            parsePrimary(List, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(List, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -91,14 +91,14 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(new, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -137,14 +137,14 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
-                            parsePrimary(List, expression)
+                            parsePrimary(List, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([])
                               parseLiteralListSuffix(List, null)
                                 rewriteSquareBrackets(List)
@@ -174,9 +174,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
@@ -224,9 +224,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
@@ -266,14 +266,14 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
-                            parsePrimary(List, expression)
+                            parsePrimary(List, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(List, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -286,9 +286,9 @@
                                 listener: endTypeArguments(1, <, >)
                                 parseLiteralListSuffix(>, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralNull([)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralList(1, [, null, ])
@@ -315,20 +315,20 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
-                            parsePrimary(List, expression)
+                            parsePrimary(List, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(List, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralNull([)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralList(1, [, null, ])
@@ -355,14 +355,14 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(new, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -375,9 +375,9 @@
                                 listener: endTypeArguments(1, <, >)
                                 parseLiteralListSuffix(>, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralNull([)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralList(1, [, null, ])
@@ -404,20 +404,20 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(new, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralNull([)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralList(1, [, null, ])

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect
index a6b3040..76650bb 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect
@@ -49,14 +49,14 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
-                            parsePrimary(Map, expression)
+                            parsePrimary(Map, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(Map, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(String, typeReference)
@@ -99,14 +99,14 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(new, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(String, typeReference)
@@ -149,14 +149,14 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
-                            parsePrimary(Map, expression)
+                            parsePrimary(Map, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Map, null)
                                 listener: handleLiteralSetOrMap(0, {, null, }, false)
@@ -187,9 +187,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
@@ -244,9 +244,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
@@ -290,14 +290,14 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
-                            parsePrimary(Map, expression)
+                            parsePrimary(Map, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(Map, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(String, typeReference)
@@ -313,17 +313,17 @@
                                 listener: endTypeArguments(2, <, >)
                                 parseLiteralSetOrMapSuffix(>, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralString({)
                                             parseSingleLiteralString({)
                                               listener: beginLiteralString("a")
                                               listener: endLiteralString(0, :)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralNull(:)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralMapEntry(:, })
@@ -355,28 +355,28 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
-                            parsePrimary(Map, expression)
+                            parsePrimary(Map, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Map, null)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralString({)
                                           parseSingleLiteralString({)
                                             listener: beginLiteralString("a")
                                             listener: endLiteralString(0, :)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralMapEntry(:, })
@@ -408,14 +408,14 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(new, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(String, typeReference)
@@ -431,17 +431,17 @@
                                 listener: endTypeArguments(2, <, >)
                                 parseLiteralSetOrMapSuffix(>, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralString({)
                                             parseSingleLiteralString({)
                                               listener: beginLiteralString("a")
                                               listener: endLiteralString(0, :)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralNull(:)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralMapEntry(:, })
@@ -473,28 +473,28 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(new, null)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralString({)
                                           parseSingleLiteralString({)
                                             listener: beginLiteralString("a")
                                             listener: endLiteralString(0, :)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralMapEntry(:, })

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect
index 2611ceb..441f223 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect
@@ -45,15 +45,15 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
-                              parsePrimary(Set, expression)
+                              parsePrimary(Set, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(Set, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(List, typeReference)
@@ -89,9 +89,9 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralListSetMapOrFunction(=, null)
                             listener: beginTypeArguments(<)
                             listener: handleIdentifier(List, typeReference)
@@ -127,15 +127,15 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
-                              parsePrimary(Set, expression)
+                              parsePrimary(Set, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments({)
                                 parseLiteralSetOrMapSuffix(Set, null)
                                   listener: handleLiteralSetOrMap(0, {, null, }, false)
@@ -162,9 +162,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -209,9 +209,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -248,15 +248,15 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
-                              parsePrimary(Set, expression)
+                              parsePrimary(Set, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(Set, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(List, typeReference)
@@ -269,9 +269,9 @@
                                   listener: endTypeArguments(1, <, >)
                                   parseLiteralSetOrMapSuffix(>, null)
                                     parseExpression({)
-                                      parsePrecedenceExpression({, 1, true)
-                                        parseUnaryExpression({, true)
-                                          parsePrimary({, expression)
+                                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                                          parsePrimary({, expression, ConstantPatternContext.none)
                                             parseLiteralNull({)
                                               listener: handleLiteralNull(null)
                                     listener: handleLiteralSetOrMap(1, {, null, }, true)
@@ -298,21 +298,21 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
-                              parsePrimary(Set, expression)
+                              parsePrimary(Set, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments({)
                                 parseLiteralSetOrMapSuffix(Set, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralNull({)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralSetOrMap(1, {, null, }, true)
@@ -339,9 +339,9 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralListSetMapOrFunction(=, null)
                             listener: beginTypeArguments(<)
                             listener: handleIdentifier(List, typeReference)
@@ -354,9 +354,9 @@
                             listener: endTypeArguments(1, <, >)
                             parseLiteralSetOrMapSuffix(>, null)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralNull({)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralSetOrMap(1, {, null, }, true)
@@ -383,15 +383,15 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           listener: handleNoTypeArguments({)
                           parseLiteralSetOrMapSuffix(=, null)
                             parseExpression({)
-                              parsePrecedenceExpression({, 1, true)
-                                parseUnaryExpression({, true)
-                                  parsePrimary({, expression)
+                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                  parsePrimary({, expression, ConstantPatternContext.none)
                                     parseLiteralNull({)
                                       listener: handleLiteralNull(null)
                             listener: handleLiteralSetOrMap(1, {, null, }, true)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_const.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_const.dart.intertwined.expect
index 01f974e..8e95984 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_const.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_const.dart.intertwined.expect
@@ -45,9 +45,9 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
@@ -88,9 +88,9 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(<)
                             parseLiteralListSetMapOrFunction(const, const)
@@ -129,9 +129,9 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
@@ -163,9 +163,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
                             parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'ComplexTypeParamOrArgInfo')
@@ -212,9 +212,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstExpression(const)
                             parseConstructorReference(const, ConstructorReferenceContext.Const, Instance of 'NoTypeParamOrArg')
@@ -253,9 +253,9 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
@@ -272,9 +272,9 @@
                               listener: endTypeArguments(1, <, >)
                               parseLiteralSetOrMapSuffix(>, const)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralNull({)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralSetOrMap(1, {, const, }, true)
@@ -302,9 +302,9 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
@@ -312,9 +312,9 @@
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(Set, const)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralNull({)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralSetOrMap(1, {, const, }, true)
@@ -342,9 +342,9 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(<)
                             parseLiteralListSetMapOrFunction(const, const)
@@ -359,9 +359,9 @@
                               listener: endTypeArguments(1, <, >)
                               parseLiteralSetOrMapSuffix(>, const)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralNull({)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralSetOrMap(1, {, const, }, true)
@@ -389,17 +389,17 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral({)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, const)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralNull({)
                                         listener: handleLiteralNull(null)
                               listener: handleLiteralSetOrMap(1, {, const, }, true)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect
index 8318586..3b786f2 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect
@@ -45,14 +45,14 @@
                 parseFieldInitializerOpt(foo1, foo1, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
-                            parsePrimary(Set, expression)
+                            parsePrimary(Set, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(Set, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -88,14 +88,14 @@
                 parseFieldInitializerOpt(foo2, foo2, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(new, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -131,14 +131,14 @@
                 parseFieldInitializerOpt(foo3, foo3, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
-                            parsePrimary(Set, expression)
+                            parsePrimary(Set, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Set, null)
                                 listener: handleLiteralSetOrMap(0, {, null, }, false)
@@ -165,9 +165,9 @@
                 parseFieldInitializerOpt(foo4, foo4, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
@@ -215,9 +215,9 @@
                 parseFieldInitializerOpt(foo5, foo5, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             listener: beginNewExpression(new)
@@ -257,14 +257,14 @@
                 parseFieldInitializerOpt(foo6, foo6, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
-                            parsePrimary(Set, expression)
+                            parsePrimary(Set, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(Set, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -277,9 +277,9 @@
                                 listener: endTypeArguments(1, <, >)
                                 parseLiteralSetOrMapSuffix(>, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralNull({)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralSetOrMap(1, {, null, }, true)
@@ -306,20 +306,20 @@
                 parseFieldInitializerOpt(foo7, foo7, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
                               listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
-                            parsePrimary(Set, expression)
+                            parsePrimary(Set, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Set, null)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralNull({)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)
@@ -346,14 +346,14 @@
                 parseFieldInitializerOpt(foo8, foo8, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(new, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(List, typeReference)
@@ -366,9 +366,9 @@
                                 listener: endTypeArguments(1, <, >)
                                 parseLiteralSetOrMapSuffix(>, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralNull({)
                                             listener: handleLiteralNull(null)
                                   listener: handleLiteralSetOrMap(1, {, null, }, true)
@@ -395,20 +395,20 @@
                 parseFieldInitializerOpt(foo9, foo9, null, null, null, null, final, DeclarationKind.Class, F)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseNewExpression(=)
                             isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
-                            parsePrimary(new, expression)
+                            parsePrimary(new, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(new, null)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralNull({)
                                           listener: handleLiteralNull(null)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect
index 928bc96..2196e5a 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect
@@ -34,9 +34,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -56,9 +56,9 @@
                           listener: handleIsOperator(is, null)
                           skipChainedAsIsOperators(int)
                         rewriter()
-                        parsePrecedenceExpression(||, 6, true)
-                          parseUnaryExpression(||, true)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                          parseUnaryExpression(||, true, ConstantPatternContext.none)
+                            parsePrimary(||, expression, ConstantPatternContext.none)
                               parseSend(||, expression)
                                 isNextIdentifier(||)
                                 ensureIdentifier(||, expression)
@@ -75,9 +75,9 @@
                       looksLikeLocalFunction(or)
                       parseExpressionStatement())
                         parseExpression())
-                          parsePrecedenceExpression(), 1, true)
-                            parseUnaryExpression(), true)
-                              parsePrimary(), expression)
+                          parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(), true, ConstantPatternContext.none)
+                              parsePrimary(), expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(), expression)
                                   parseSend(), expression)
                                     isNextIdentifier())

pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect
index fda88e1..42d03fc 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect
@@ -81,9 +81,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -103,9 +103,9 @@
                                   listener: handleIsOperator(is, !)
                                   skipChainedAsIsOperators(T)
                                 rewriter()
-                                parsePrecedenceExpression(||, 6, true)
-                                  parseUnaryExpression(||, true)
-                                    parsePrimary(||, expression)
+                                parsePrecedenceExpression(||, 6, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(||, true, ConstantPatternContext.none)
+                                    parsePrimary(||, expression, ConstantPatternContext.none)
                                       parseSend(||, expression)
                                         isNextIdentifier(||)
                                         ensureIdentifier(||, expression)
@@ -122,9 +122,9 @@
                               looksLikeLocalFunction(or)
                               parseExpressionStatement())
                                 parseExpression())
-                                  parsePrecedenceExpression(), 1, true)
-                                    parseUnaryExpression(), true)
-                                      parsePrimary(), expression)
+                                  parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(), true, ConstantPatternContext.none)
+                                      parsePrimary(), expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(), expression)
                                           parseSend(), expression)
                                             isNextIdentifier())

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48288.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48288.dart.intertwined.expect
index 7d75e4f..5cd52d7 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48288.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48288.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -65,18 +65,18 @@
                                         rewriter()
                                       listener: handleIdentifier(, namedArgumentReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(1)
                                     listener: handleNamedArgument(:)
                                     ensureIdentifier(,, namedArgumentReference)
                                       listener: handleIdentifier(bbb, namedArgumentReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(0)
                                     listener: handleNamedArgument(:)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48288_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48288_prime.dart.intertwined.expect
index dec0289..cd2d9a5 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48288_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48288_prime.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -61,18 +61,18 @@
                                     ensureIdentifier((, namedArgumentReference)
                                       listener: handleIdentifier(foo, namedArgumentReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(1)
                                     listener: handleNamedArgument(:)
                                     ensureIdentifier(,, namedArgumentReference)
                                       listener: handleIdentifier(bbb, namedArgumentReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(0)
                                     listener: handleNamedArgument(:)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48371_prime3.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48371_prime3.dart.intertwined.expect
index c3ce0fd..48823b6 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48371_prime3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48371_prime3.dart.intertwined.expect
@@ -107,9 +107,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -122,9 +122,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -135,9 +135,9 @@
                                                           listener: handleNoArguments(*)
                                                         listener: handleSend(x, *)
                                                 listener: beginBinaryExpression(*)
-                                                parsePrecedenceExpression(*, 15, true)
-                                                  parseUnaryExpression(*, true)
-                                                    parsePrimary(*, expression)
+                                                parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                                    parsePrimary(*, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(*)
                                                         listener: handleLiteralInt(42)
                                                 listener: endBinaryExpression(*)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48380_4.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48380_4.dart.intertwined.expect
index 8d07860..fa039e1 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48380_4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48380_4.dart.intertwined.expect
@@ -69,9 +69,9 @@
                     looksLikeLocalFunction(print)
                     parseExpressionStatement({)
                       parseExpression({)
-                        parsePrecedenceExpression({, 1, true)
-                          parseUnaryExpression({, true)
-                            parsePrimary({, expression)
+                        parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression({, true, ConstantPatternContext.none)
+                            parsePrimary({, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral({, expression)
                                 looksLikeFunctionBody(;)
                                 parseSend({, expression)
@@ -84,9 +84,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseLiteralString(()
                                                   parseSingleLiteralString(()
                                                     listener: beginLiteralString("hello")
@@ -101,9 +101,9 @@
                   parseReturnStatement(;)
                     listener: beginReturnStatement(return)
                     parseExpression(return)
-                      parsePrecedenceExpression(return, 1, true)
-                        parseUnaryExpression(return, true)
-                          parsePrimary(return, expression)
+                      parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(return, true, ConstantPatternContext.none)
+                          parsePrimary(return, expression, ConstantPatternContext.none)
                             parseLiteralString(return)
                               parseSingleLiteralString(return)
                                 listener: beginLiteralString("hello")

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48411.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48411.dart.intertwined.expect
index ce81d7f..339a075 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48411.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48411.dart.intertwined.expect
@@ -183,9 +183,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -196,9 +196,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -212,9 +212,9 @@
                       parseSuperInitializerExpression(,)
                         parseInitializerExpressionRest(,)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSuperExpression(,, expression)
                                     listener: handleSuperExpression(super, expression)
                                     listener: handleNoTypeArguments(()
@@ -222,9 +222,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -316,9 +316,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -329,9 +329,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -345,12 +345,12 @@
                       parseSuperInitializerExpression(,)
                         parseInitializerExpressionRest(,)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSuperExpression(,, expression)
                                     listener: handleSuperExpression(super, expression)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -362,9 +362,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -457,9 +457,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -470,9 +470,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -485,12 +485,12 @@
                       listener: beginInitializer(this)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseThisExpression(,, expression)
                                   listener: handleThisExpression(this, expression)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -502,9 +502,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -660,9 +660,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -673,9 +673,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -688,9 +688,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -700,15 +700,15 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                                     listener: handleLiteralInt(2)
                               listener: beginBinaryExpression(*)
-                              parsePrecedenceExpression(*, 15, true)
-                                parseUnaryExpression(*, true)
-                                  parsePrimary(*, expression)
+                              parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                  parsePrimary(*, expression, ConstantPatternContext.none)
                                     parseLiteralInt(*)
                                       listener: handleLiteralInt(21)
                               listener: endBinaryExpression(*)
@@ -793,9 +793,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -806,9 +806,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -822,9 +822,9 @@
                       parseAssert(,, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -835,16 +835,16 @@
                                       listener: handleNoArguments(-)
                                     listener: handleSend(x, -)
                             listener: beginBinaryExpression(-)
-                            parsePrecedenceExpression(-, 14, true)
-                              parseUnaryExpression(-, true)
-                                parsePrimary(-, expression)
+                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                parsePrimary(-, expression, ConstantPatternContext.none)
                                   parseLiteralInt(-)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(-)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -946,9 +946,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -959,9 +959,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -974,12 +974,12 @@
                       listener: beginInitializer(this)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseThisExpression(,, expression)
                                   listener: handleThisExpression(this, expression)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -990,9 +990,9 @@
                                     listener: handleNoArguments(=)
                                   listener: handleSend(y, =)
                             listener: handleEndingBinaryExpression(.)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -1003,9 +1003,9 @@
                                         listener: handleNoArguments(*)
                                       listener: handleSend(x, *)
                               listener: beginBinaryExpression(*)
-                              parsePrecedenceExpression(*, 15, true)
-                                parseUnaryExpression(*, true)
-                                  parsePrimary(*, expression)
+                              parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                  parsePrimary(*, expression, ConstantPatternContext.none)
                                     parseLiteralInt(*)
                                       listener: handleLiteralInt(2)
                               listener: endBinaryExpression(*)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime.dart.intertwined.expect
index 5876b66..5b23f79 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime.dart.intertwined.expect
@@ -183,9 +183,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -196,9 +196,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -209,9 +209,9 @@
                       parseSuperInitializerExpression(,)
                         parseInitializerExpressionRest(,)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSuperExpression(,, expression)
                                     listener: handleSuperExpression(super, expression)
                                     listener: handleNoTypeArguments(()
@@ -219,9 +219,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -313,9 +313,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -326,9 +326,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -339,12 +339,12 @@
                       parseSuperInitializerExpression(,)
                         parseInitializerExpressionRest(,)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSuperExpression(,, expression)
                                     listener: handleSuperExpression(super, expression)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -356,9 +356,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -451,9 +451,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -464,9 +464,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -476,12 +476,12 @@
                       listener: beginInitializer(this)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseThisExpression(,, expression)
                                   listener: handleThisExpression(this, expression)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -493,9 +493,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -651,9 +651,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -664,9 +664,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -676,9 +676,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -688,15 +688,15 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                                     listener: handleLiteralInt(2)
                               listener: beginBinaryExpression(*)
-                              parsePrecedenceExpression(*, 15, true)
-                                parseUnaryExpression(*, true)
-                                  parsePrimary(*, expression)
+                              parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                  parsePrimary(*, expression, ConstantPatternContext.none)
                                     parseLiteralInt(*)
                                       listener: handleLiteralInt(21)
                               listener: endBinaryExpression(*)
@@ -781,9 +781,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -794,9 +794,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -807,9 +807,9 @@
                       parseAssert(,, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -820,16 +820,16 @@
                                       listener: handleNoArguments(-)
                                     listener: handleSend(x, -)
                             listener: beginBinaryExpression(-)
-                            parsePrecedenceExpression(-, 14, true)
-                              parseUnaryExpression(-, true)
-                                parsePrimary(-, expression)
+                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                parsePrimary(-, expression, ConstantPatternContext.none)
                                   parseLiteralInt(-)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(-)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -931,9 +931,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -944,9 +944,9 @@
                                       listener: handleNoArguments(>)
                                     listener: handleSend(x, >)
                             listener: beginBinaryExpression(>)
-                            parsePrecedenceExpression(>, 9, true)
-                              parseUnaryExpression(>, true)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                              parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: endBinaryExpression(>)
@@ -956,12 +956,12 @@
                       listener: beginInitializer(this)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseThisExpression(,, expression)
                                   listener: handleThisExpression(this, expression)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -972,9 +972,9 @@
                                     listener: handleNoArguments(=)
                                   listener: handleSend(y, =)
                             listener: handleEndingBinaryExpression(.)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -985,9 +985,9 @@
                                         listener: handleNoArguments(*)
                                       listener: handleSend(x, *)
                               listener: beginBinaryExpression(*)
-                              parsePrecedenceExpression(*, 15, true)
-                                parseUnaryExpression(*, true)
-                                  parsePrimary(*, expression)
+                              parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                  parsePrimary(*, expression, ConstantPatternContext.none)
                                     parseLiteralInt(*)
                                       listener: handleLiteralInt(2)
                               listener: endBinaryExpression(*)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime_1.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime_1.dart.intertwined.expect
index 61ed23f1..a334de3 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime_1.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_48411_prime_1.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           listener: handleRecoverableError(Message[ExpectedButGot, Expected '(' before this., null, {string: (}], =, =)
                         rewriter()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -179,9 +179,9 @@
                       rewriter()
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -191,9 +191,9 @@
                                     parseArgumentsOpt()
                                       listener: handleNoArguments(=)
                                     listener: handleSend(, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -353,14 +353,14 @@
                       parseSuperInitializerExpression(:)
                         parseInitializerExpressionRest(:)
                           parseExpression(:)
-                            parsePrecedenceExpression(:, 1, true)
-                              parseUnaryExpression(:, true)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                parsePrimary(:, expression, ConstantPatternContext.none)
                                   parseSuperExpression(:, expression)
                                     listener: handleSuperExpression(super, expression)
-                              parsePrecedenceExpression(=, 1, true)
-                                parseUnaryExpression(=, true)
-                                  parsePrimary(=, expression)
+                              parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                  parsePrimary(=, expression, ConstantPatternContext.none)
                                     parseLiteralInt(=)
                                       listener: handleLiteralInt(0)
                               listener: handleAssignmentExpression(=)
@@ -437,9 +437,9 @@
                       rewriter()
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -449,12 +449,12 @@
                                     parseArgumentsOpt()
                                       listener: handleNoArguments(=)
                                     listener: handleSend(, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseThisExpression(=, expression)
                                     listener: handleThisExpression(this, expression)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -465,9 +465,9 @@
                                       listener: handleNoArguments(=)
                                     listener: handleSend(, =)
                               listener: handleEndingBinaryExpression(.)
-                              parsePrecedenceExpression(=, 1, true)
-                                parseUnaryExpression(=, true)
-                                  parsePrimary(=, expression)
+                              parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                  parsePrimary(=, expression, ConstantPatternContext.none)
                                     parseLiteralInt(=)
                                       listener: handleLiteralInt(0)
                               listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect
index 169ee87..4018f99 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_49116.dart.intertwined.expect
@@ -32,9 +32,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseNewExpression(=>)
                       isNextIdentifier(new)
                       listener: beginNewExpression(new)
@@ -54,9 +54,9 @@
                         parseArgumentsRest(()
                           listener: beginArguments(()
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseLiteralBool(()
                                     listener: handleLiteralBool(true)
                           listener: endArguments(1, (, ))
@@ -97,16 +97,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement({)
                 parseExpression({)
-                  parsePrecedenceExpression({, 1, true)
-                    parseUnaryExpression({, true)
+                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression({, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression({, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression({, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 looksLikeFunctionBody(;)
                                 parseSend(await, expression)
@@ -134,16 +134,16 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
                           inPlainSync()
                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                           parseAwaitExpression((, true)
                             listener: beginAwaitExpression(await)
-                            parsePrecedenceExpression(await, 16, true)
-                              parseUnaryExpression(await, true)
-                                parsePrimary(await, expression)
+                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                parsePrimary(await, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(await, expression)
                                     looksLikeFunctionBody())
                                     parseSend(await, expression)
@@ -180,18 +180,18 @@
                       ensureParenthesizedCondition(if, allowCase: false)
                         parseExpressionInParenthesisRest((, allowCase: false)
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrecedenceExpression(!, 16, true)
-                                  parseUnaryExpression(!, true)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(!, true, ConstantPatternContext.none)
                                     inPlainSync()
                                     looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                       looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                     parseAwaitExpression(!, true)
                                       listener: beginAwaitExpression(await)
-                                      parsePrecedenceExpression(await, 16, true)
-                                        parseUnaryExpression(await, true)
-                                          parsePrimary(await, expression)
+                                      parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                          parsePrimary(await, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(await, expression)
                                               looksLikeFunctionBody())
                                               parseSend(await, expression)
@@ -231,9 +231,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             looksLikeFunctionBody(;)
                             parseSend(}, expression)
@@ -246,16 +246,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody())
                                                     parseSend(await, expression)
@@ -284,9 +284,9 @@
                 looksLikeLocalFunction(xor)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -299,16 +299,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody(,)
                                                     parseSend(await, expression)
@@ -327,16 +327,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression(,, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody(,)
                                                     parseSend(await, expression)
@@ -355,16 +355,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression(,, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody())
                                                     parseSend(await, expression)
@@ -394,16 +394,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement(;)
                 parseExpression(;)
-                  parsePrecedenceExpression(;, 1, true)
-                    parseUnaryExpression(;, true)
+                  parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(;, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression(;, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 looksLikeFunctionBody(^)
                                 parseSend(await, expression)
@@ -422,16 +422,16 @@
                           listener: handleRecoverableError(AwaitNotAsync, await, await)
                         listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                     listener: beginBinaryExpression(^)
-                    parsePrecedenceExpression(^, 11, true)
-                      parseUnaryExpression(^, true)
+                    parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                      parseUnaryExpression(^, true, ConstantPatternContext.none)
                         inPlainSync()
                         looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                           looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                         parseAwaitExpression(^, true)
                           listener: beginAwaitExpression(await)
-                          parsePrecedenceExpression(await, 16, true)
-                            parseUnaryExpression(await, true)
-                              parsePrimary(await, expression)
+                          parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(await, true, ConstantPatternContext.none)
+                              parsePrimary(await, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(await, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(await, expression)
@@ -459,9 +459,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -474,16 +474,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody(^)
                                                     parseSend(await, expression)
@@ -502,16 +502,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                         listener: beginBinaryExpression(^)
-                                        parsePrecedenceExpression(^, 11, true)
-                                          parseUnaryExpression(^, true)
+                                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(^, true, ConstantPatternContext.none)
                                             inPlainSync()
                                             looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                                               looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                             parseAwaitExpression(^, true)
                                               listener: beginAwaitExpression(await)
-                                              parsePrecedenceExpression(await, 16, true)
-                                                parseUnaryExpression(await, true)
-                                                  parsePrimary(await, expression)
+                                              parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                  parsePrimary(await, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(await, expression)
                                                       looksLikeFunctionBody())
                                                       parseSend(await, expression)
@@ -542,16 +542,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement(;)
                 parseExpression(;)
-                  parsePrecedenceExpression(;, 1, true)
-                    parseUnaryExpression(;, true)
+                  parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(;, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression(;, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 looksLikeFunctionBody(+)
                                 parseSend(await, expression)
@@ -570,16 +570,16 @@
                           listener: handleRecoverableError(AwaitNotAsync, await, await)
                         listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
                         inPlainSync()
                         looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                           looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                         parseAwaitExpression(+, true)
                           listener: beginAwaitExpression(await)
-                          parsePrecedenceExpression(await, 16, true)
-                            parseUnaryExpression(await, true)
-                              parsePrimary(await, expression)
+                          parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(await, true, ConstantPatternContext.none)
+                              parsePrimary(await, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(await, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(await, expression)
@@ -607,9 +607,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -622,16 +622,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody(+)
                                                     parseSend(await, expression)
@@ -650,16 +650,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                                         listener: beginBinaryExpression(+)
-                                        parsePrecedenceExpression(+, 14, true)
-                                          parseUnaryExpression(+, true)
+                                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(+, true, ConstantPatternContext.none)
                                             inPlainSync()
                                             looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                                               looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                             parseAwaitExpression(+, true)
                                               listener: beginAwaitExpression(await)
-                                              parsePrecedenceExpression(await, 16, true)
-                                                parseUnaryExpression(await, true)
-                                                  parsePrimary(await, expression)
+                                              parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                  parsePrimary(await, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(await, expression)
                                                       looksLikeFunctionBody())
                                                       parseSend(await, expression)
@@ -690,16 +690,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement(;)
                 parseExpression(;)
-                  parsePrecedenceExpression(;, 1, true)
-                    parseUnaryExpression(;, true)
+                  parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(;, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression(;, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 looksLikeFunctionBody(-)
                                 parseSend(await, expression)
@@ -718,16 +718,16 @@
                           listener: handleRecoverableError(AwaitNotAsync, await, await)
                         listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                     listener: beginBinaryExpression(-)
-                    parsePrecedenceExpression(-, 14, true)
-                      parseUnaryExpression(-, true)
+                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(-, true, ConstantPatternContext.none)
                         inPlainSync()
                         looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                           looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                         parseAwaitExpression(-, true)
                           listener: beginAwaitExpression(await)
-                          parsePrecedenceExpression(await, 16, true)
-                            parseUnaryExpression(await, true)
-                              parsePrimary(await, expression)
+                          parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(await, true, ConstantPatternContext.none)
+                              parsePrimary(await, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(await, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(await, expression)
@@ -755,9 +755,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -770,16 +770,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     looksLikeFunctionBody(-)
                                                     parseSend(await, expression)
@@ -798,16 +798,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                                         listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
+                                        parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(-, true, ConstantPatternContext.none)
                                             inPlainSync()
                                             looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                                               looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                             parseAwaitExpression(-, true)
                                               listener: beginAwaitExpression(await)
-                                              parsePrecedenceExpression(await, 16, true)
-                                                parseUnaryExpression(await, true)
-                                                  parsePrimary(await, expression)
+                                              parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                  parsePrimary(await, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(await, expression)
                                                       looksLikeFunctionBody())
                                                       parseSend(await, expression)
@@ -838,18 +838,18 @@
                   looksLikeLocalFunction(!)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrecedenceExpression(!, 16, true)
-                            parseUnaryExpression(!, true)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(!, true, ConstantPatternContext.none)
                               inPlainSync()
                               looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                               parseAwaitExpression(!, true)
                                 listener: beginAwaitExpression(await)
-                                parsePrecedenceExpression(await, 16, true)
-                                  parseUnaryExpression(await, true)
-                                    parsePrimary(await, expression)
+                                parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                    parsePrimary(await, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(await, expression)
                                         looksLikeFunctionBody(^)
                                         parseSend(await, expression)
@@ -869,18 +869,18 @@
                                 listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                           listener: handleUnaryPrefixExpression(!)
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrecedenceExpression(!, 16, true)
-                              parseUnaryExpression(!, true)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                              parseUnaryExpression(!, true, ConstantPatternContext.none)
                                 inPlainSync()
                                 looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                   looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                 parseAwaitExpression(!, true)
                                   listener: beginAwaitExpression(await)
-                                  parsePrecedenceExpression(await, 16, true)
-                                    parseUnaryExpression(await, true)
-                                      parsePrimary(await, expression)
+                                  parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                      parsePrimary(await, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(await, expression)
                                           looksLikeFunctionBody(;)
                                           parseSend(await, expression)
@@ -909,9 +909,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -924,18 +924,18 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrecedenceExpression(!, 16, true)
-                                            parseUnaryExpression(!, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(!, true, ConstantPatternContext.none)
                                               inPlainSync()
                                               looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                               parseAwaitExpression(!, true)
                                                 listener: beginAwaitExpression(await)
-                                                parsePrecedenceExpression(await, 16, true)
-                                                  parseUnaryExpression(await, true)
-                                                    parsePrimary(await, expression)
+                                                parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                    parsePrimary(await, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(await, expression)
                                                         looksLikeFunctionBody(^)
                                                         parseSend(await, expression)
@@ -955,18 +955,18 @@
                                                 listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                           listener: handleUnaryPrefixExpression(!)
                                         listener: beginBinaryExpression(^)
-                                        parsePrecedenceExpression(^, 11, true)
-                                          parseUnaryExpression(^, true)
-                                            parsePrecedenceExpression(!, 16, true)
-                                              parseUnaryExpression(!, true)
+                                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                            parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(!, true, ConstantPatternContext.none)
                                                 inPlainSync()
                                                 looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                   looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                                 parseAwaitExpression(!, true)
                                                   listener: beginAwaitExpression(await)
-                                                  parsePrecedenceExpression(await, 16, true)
-                                                    parseUnaryExpression(await, true)
-                                                      parsePrimary(await, expression)
+                                                  parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                      parsePrimary(await, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral(await, expression)
                                                           looksLikeFunctionBody())
                                                           parseSend(await, expression)
@@ -1007,9 +1007,9 @@
                     parseVariableInitializerOpt(f)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 looksLikeFunctionBody(;)
                                 parseSend(=, expression)
@@ -1060,16 +1060,16 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
                           inPlainSync()
                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                           parseAwaitExpression((, true)
                             listener: beginAwaitExpression(await)
-                            parsePrecedenceExpression(await, 16, true)
-                              parseUnaryExpression(await, true)
-                                parsePrimary(await, expression)
+                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                parsePrimary(await, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(await, expression)
                                     parseSend(await, expression)
                                       isNextIdentifier(await)
@@ -1102,18 +1102,18 @@
                       ensureParenthesizedCondition(if, allowCase: false)
                         parseExpressionInParenthesisRest((, allowCase: false)
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrecedenceExpression(!, 16, true)
-                                  parseUnaryExpression(!, true)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(!, true, ConstantPatternContext.none)
                                     inPlainSync()
                                     looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                       looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                     parseAwaitExpression(!, true)
                                       listener: beginAwaitExpression(await)
-                                      parsePrecedenceExpression(await, 16, true)
-                                        parseUnaryExpression(await, true)
-                                          parsePrimary(await, expression)
+                                      parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                          parsePrimary(await, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(await, expression)
                                               parseSend(await, expression)
                                                 isNextIdentifier(await)
@@ -1149,9 +1149,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             looksLikeFunctionBody(;)
                             parseSend(}, expression)
@@ -1164,16 +1164,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1198,9 +1198,9 @@
                 looksLikeLocalFunction(xor)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -1213,16 +1213,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1237,16 +1237,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression(,, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1261,16 +1261,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, ,, AwaitNotAsync)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression(,, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression(,, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1296,16 +1296,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement(;)
                 parseExpression(;)
-                  parsePrecedenceExpression(;, 1, true)
-                    parseUnaryExpression(;, true)
+                  parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(;, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression(;, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 parseSend(await, expression)
                                   isNextIdentifier(await)
@@ -1320,16 +1320,16 @@
                           listener: handleRecoverableError(AwaitNotAsync, await, await)
                         listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                     listener: beginBinaryExpression(^)
-                    parsePrecedenceExpression(^, 11, true)
-                      parseUnaryExpression(^, true)
+                    parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                      parseUnaryExpression(^, true, ConstantPatternContext.none)
                         inPlainSync()
                         looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                           looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                         parseAwaitExpression(^, true)
                           listener: beginAwaitExpression(await)
-                          parsePrecedenceExpression(await, 16, true)
-                            parseUnaryExpression(await, true)
-                              parsePrimary(await, expression)
+                          parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(await, true, ConstantPatternContext.none)
+                              parsePrimary(await, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(await, expression)
                                   parseSend(await, expression)
                                     isNextIdentifier(await)
@@ -1353,9 +1353,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -1368,16 +1368,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1392,16 +1392,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                         listener: beginBinaryExpression(^)
-                                        parsePrecedenceExpression(^, 11, true)
-                                          parseUnaryExpression(^, true)
+                                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(^, true, ConstantPatternContext.none)
                                             inPlainSync()
                                             looksLikeAwaitExpression(^, AwaitOrYieldContext.UnaryExpression)
                                               looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                             parseAwaitExpression(^, true)
                                               listener: beginAwaitExpression(await)
-                                              parsePrecedenceExpression(await, 16, true)
-                                                parseUnaryExpression(await, true)
-                                                  parsePrimary(await, expression)
+                                              parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                  parsePrimary(await, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(await, expression)
                                                       parseSend(await, expression)
                                                         isNextIdentifier(await)
@@ -1428,16 +1428,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement(;)
                 parseExpression(;)
-                  parsePrecedenceExpression(;, 1, true)
-                    parseUnaryExpression(;, true)
+                  parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(;, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression(;, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 parseSend(await, expression)
                                   isNextIdentifier(await)
@@ -1452,16 +1452,16 @@
                           listener: handleRecoverableError(AwaitNotAsync, await, await)
                         listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
                         inPlainSync()
                         looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                           looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                         parseAwaitExpression(+, true)
                           listener: beginAwaitExpression(await)
-                          parsePrecedenceExpression(await, 16, true)
-                            parseUnaryExpression(await, true)
-                              parsePrimary(await, expression)
+                          parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(await, true, ConstantPatternContext.none)
+                              parsePrimary(await, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(await, expression)
                                   parseSend(await, expression)
                                     isNextIdentifier(await)
@@ -1485,9 +1485,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -1500,16 +1500,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1524,16 +1524,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, +, AwaitNotAsync)
                                         listener: beginBinaryExpression(+)
-                                        parsePrecedenceExpression(+, 14, true)
-                                          parseUnaryExpression(+, true)
+                                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(+, true, ConstantPatternContext.none)
                                             inPlainSync()
                                             looksLikeAwaitExpression(+, AwaitOrYieldContext.UnaryExpression)
                                               looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                             parseAwaitExpression(+, true)
                                               listener: beginAwaitExpression(await)
-                                              parsePrecedenceExpression(await, 16, true)
-                                                parseUnaryExpression(await, true)
-                                                  parsePrimary(await, expression)
+                                              parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                  parsePrimary(await, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(await, expression)
                                                       parseSend(await, expression)
                                                         isNextIdentifier(await)
@@ -1560,16 +1560,16 @@
                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.Statement)
               parseExpressionStatement(;)
                 parseExpression(;)
-                  parsePrecedenceExpression(;, 1, true)
-                    parseUnaryExpression(;, true)
+                  parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(;, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(;, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                       parseAwaitExpression(;, true)
                         listener: beginAwaitExpression(await)
-                        parsePrecedenceExpression(await, 16, true)
-                          parseUnaryExpression(await, true)
-                            parsePrimary(await, expression)
+                        parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                          parseUnaryExpression(await, true, ConstantPatternContext.none)
+                            parsePrimary(await, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(await, expression)
                                 parseSend(await, expression)
                                   isNextIdentifier(await)
@@ -1584,16 +1584,16 @@
                           listener: handleRecoverableError(AwaitNotAsync, await, await)
                         listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                     listener: beginBinaryExpression(-)
-                    parsePrecedenceExpression(-, 14, true)
-                      parseUnaryExpression(-, true)
+                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(-, true, ConstantPatternContext.none)
                         inPlainSync()
                         looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                           looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                         parseAwaitExpression(-, true)
                           listener: beginAwaitExpression(await)
-                          parsePrecedenceExpression(await, 16, true)
-                            parseUnaryExpression(await, true)
-                              parsePrimary(await, expression)
+                          parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(await, true, ConstantPatternContext.none)
+                              parsePrimary(await, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(await, expression)
                                   parseSend(await, expression)
                                     isNextIdentifier(await)
@@ -1617,9 +1617,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -1632,16 +1632,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
                                           inPlainSync()
                                           looksLikeAwaitExpression((, AwaitOrYieldContext.UnaryExpression)
                                             looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                           parseAwaitExpression((, true)
                                             listener: beginAwaitExpression(await)
-                                            parsePrecedenceExpression(await, 16, true)
-                                              parseUnaryExpression(await, true)
-                                                parsePrimary(await, expression)
+                                            parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                parsePrimary(await, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(await, expression)
                                                     parseSend(await, expression)
                                                       isNextIdentifier(await)
@@ -1656,16 +1656,16 @@
                                               listener: handleRecoverableError(AwaitNotAsync, await, await)
                                             listener: endInvalidAwaitExpression(await, -, AwaitNotAsync)
                                         listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
+                                        parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(-, true, ConstantPatternContext.none)
                                             inPlainSync()
                                             looksLikeAwaitExpression(-, AwaitOrYieldContext.UnaryExpression)
                                               looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                             parseAwaitExpression(-, true)
                                               listener: beginAwaitExpression(await)
-                                              parsePrecedenceExpression(await, 16, true)
-                                                parseUnaryExpression(await, true)
-                                                  parsePrimary(await, expression)
+                                              parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                  parsePrimary(await, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(await, expression)
                                                       parseSend(await, expression)
                                                         isNextIdentifier(await)
@@ -1692,18 +1692,18 @@
                   looksLikeLocalFunction(!)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrecedenceExpression(!, 16, true)
-                            parseUnaryExpression(!, true)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(!, true, ConstantPatternContext.none)
                               inPlainSync()
                               looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                               parseAwaitExpression(!, true)
                                 listener: beginAwaitExpression(await)
-                                parsePrecedenceExpression(await, 16, true)
-                                  parseUnaryExpression(await, true)
-                                    parsePrimary(await, expression)
+                                parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                    parsePrimary(await, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(await, expression)
                                         parseSend(await, expression)
                                           isNextIdentifier(await)
@@ -1719,18 +1719,18 @@
                                 listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                           listener: handleUnaryPrefixExpression(!)
                         listener: beginBinaryExpression(^)
-                        parsePrecedenceExpression(^, 11, true)
-                          parseUnaryExpression(^, true)
-                            parsePrecedenceExpression(!, 16, true)
-                              parseUnaryExpression(!, true)
+                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                            parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                              parseUnaryExpression(!, true, ConstantPatternContext.none)
                                 inPlainSync()
                                 looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                   looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                 parseAwaitExpression(!, true)
                                   listener: beginAwaitExpression(await)
-                                  parsePrecedenceExpression(await, 16, true)
-                                    parseUnaryExpression(await, true)
-                                      parsePrimary(await, expression)
+                                  parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                      parsePrimary(await, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(await, expression)
                                           parseSend(await, expression)
                                             isNextIdentifier(await)
@@ -1755,9 +1755,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -1770,18 +1770,18 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrecedenceExpression(!, 16, true)
-                                            parseUnaryExpression(!, true)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(!, true, ConstantPatternContext.none)
                                               inPlainSync()
                                               looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                               parseAwaitExpression(!, true)
                                                 listener: beginAwaitExpression(await)
-                                                parsePrecedenceExpression(await, 16, true)
-                                                  parseUnaryExpression(await, true)
-                                                    parsePrimary(await, expression)
+                                                parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                    parsePrimary(await, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(await, expression)
                                                         parseSend(await, expression)
                                                           isNextIdentifier(await)
@@ -1797,18 +1797,18 @@
                                                 listener: endInvalidAwaitExpression(await, ^, AwaitNotAsync)
                                           listener: handleUnaryPrefixExpression(!)
                                         listener: beginBinaryExpression(^)
-                                        parsePrecedenceExpression(^, 11, true)
-                                          parseUnaryExpression(^, true)
-                                            parsePrecedenceExpression(!, 16, true)
-                                              parseUnaryExpression(!, true)
+                                        parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                            parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(!, true, ConstantPatternContext.none)
                                                 inPlainSync()
                                                 looksLikeAwaitExpression(!, AwaitOrYieldContext.UnaryExpression)
                                                   looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
                                                 parseAwaitExpression(!, true)
                                                   listener: beginAwaitExpression(await)
-                                                  parsePrecedenceExpression(await, 16, true)
-                                                    parseUnaryExpression(await, true)
-                                                      parsePrimary(await, expression)
+                                                  parsePrecedenceExpression(await, 16, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(await, true, ConstantPatternContext.none)
+                                                      parsePrimary(await, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral(await, expression)
                                                           parseSend(await, expression)
                                                             isNextIdentifier(await)
@@ -1908,12 +1908,12 @@
                       parseVariableInitializerOpt(x2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
                               inPlainSync()
                               looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
-                              parsePrimary(=, expression)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -1952,12 +1952,12 @@
                       parseVariableInitializerOpt(y2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
                               inPlainSync()
                               looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
-                              parsePrimary(=, expression)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -1978,12 +1978,12 @@
                       parseVariableInitializerOpt(z2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
                               inPlainSync()
                               looksLikeAwaitExpression(=, AwaitOrYieldContext.UnaryExpression)
                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
-                              parsePrimary(=, expression)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -2050,9 +2050,9 @@
                             parseReturnStatement({)
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseNewExpression(return)
                                         isNextIdentifier(new)
                                         listener: beginNewExpression(new)
@@ -2151,9 +2151,9 @@
                             parseReturnStatement({)
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(return, expression)
                                         parseSend(return, expression)
                                           isNextIdentifier(return)
@@ -2240,9 +2240,9 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
                             isNextIdentifier(return)
@@ -2253,9 +2253,9 @@
                               listener: handleNoArguments(^)
                             listener: handleSend(b, ^)
                     listener: beginBinaryExpression(^)
-                    parsePrecedenceExpression(^, 11, true)
-                      parseUnaryExpression(^, true)
-                        parsePrimary(^, expression)
+                    parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                      parseUnaryExpression(^, true, ConstantPatternContext.none)
+                        parsePrimary(^, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(^, expression)
                             parseSend(^, expression)
                               isNextIdentifier(^)
@@ -2267,9 +2267,9 @@
                               listener: handleSend(b, ^)
                     listener: endBinaryExpression(^)
                     listener: beginBinaryExpression(^)
-                    parsePrecedenceExpression(^, 11, true)
-                      parseUnaryExpression(^, true)
-                        parsePrimary(^, expression)
+                    parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                      parseUnaryExpression(^, true, ConstantPatternContext.none)
+                        parsePrimary(^, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(^, expression)
                             parseSend(^, expression)
                               isNextIdentifier(^)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok.dart.intertwined.expect
index c9afca4..3529b06 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok.dart.intertwined.expect
@@ -50,9 +50,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -128,9 +128,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -206,9 +206,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -284,9 +284,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -338,9 +338,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok_prime.dart.intertwined.expect
index 3f24264..ecfd519 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_50908_ok_prime.dart.intertwined.expect
@@ -49,9 +49,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -125,9 +125,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -201,9 +201,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -277,9 +277,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)
@@ -330,9 +330,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralNull(=>)
                       listener: handleLiteralNull(null)
             ensureSemicolon(null)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_fields.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_fields.dart.intertwined.expect
index ff94ed2..fa9429d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_fields.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_fields.dart.intertwined.expect
@@ -41,9 +41,9 @@
                 parseFieldInitializerOpt(abstract, abstract, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -65,9 +65,9 @@
                 parseFieldInitializerOpt(as, as, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -93,9 +93,9 @@
                 parseFieldInitializerOpt(assert, assert, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -117,9 +117,9 @@
                 parseFieldInitializerOpt(async, async, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -141,9 +141,9 @@
                 parseFieldInitializerOpt(await, await, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -169,9 +169,9 @@
                 parseFieldInitializerOpt(break, break, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -197,9 +197,9 @@
                 parseFieldInitializerOpt(case, case, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -225,9 +225,9 @@
                 parseFieldInitializerOpt(catch, catch, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -253,9 +253,9 @@
                 parseFieldInitializerOpt(class, class, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -281,9 +281,9 @@
                 parseFieldInitializerOpt(const, const, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -309,9 +309,9 @@
                 parseFieldInitializerOpt(continue, continue, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -333,9 +333,9 @@
                 parseFieldInitializerOpt(covariant, covariant, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -361,9 +361,9 @@
                 parseFieldInitializerOpt(default, default, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -385,9 +385,9 @@
                 parseFieldInitializerOpt(deferred, deferred, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -413,9 +413,9 @@
                 parseFieldInitializerOpt(do, do, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -437,9 +437,9 @@
                 parseFieldInitializerOpt(dynamic, dynamic, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -465,9 +465,9 @@
                 parseFieldInitializerOpt(else, else, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -493,9 +493,9 @@
                 parseFieldInitializerOpt(enum, enum, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -517,9 +517,9 @@
                 parseFieldInitializerOpt(export, export, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -545,9 +545,9 @@
                 parseFieldInitializerOpt(extends, extends, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -569,9 +569,9 @@
                 parseFieldInitializerOpt(extension, extension, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -593,9 +593,9 @@
                 parseFieldInitializerOpt(external, external, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -617,9 +617,9 @@
                 parseFieldInitializerOpt(factory, factory, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -645,9 +645,9 @@
                 parseFieldInitializerOpt(false, false, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -673,9 +673,9 @@
                 parseFieldInitializerOpt(final, final, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -701,9 +701,9 @@
                 parseFieldInitializerOpt(finally, finally, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -729,9 +729,9 @@
                 parseFieldInitializerOpt(for, for, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -753,9 +753,9 @@
                 parseFieldInitializerOpt(Function, Function, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -778,9 +778,9 @@
                 parseFieldInitializerOpt(get, get, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -802,9 +802,9 @@
                 parseFieldInitializerOpt(hide, hide, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -830,9 +830,9 @@
                 parseFieldInitializerOpt(if, if, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -854,9 +854,9 @@
                 parseFieldInitializerOpt(implements, implements, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -878,9 +878,9 @@
                 parseFieldInitializerOpt(import, import, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -906,9 +906,9 @@
                 parseFieldInitializerOpt(in, in, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -930,9 +930,9 @@
                 parseFieldInitializerOpt(inout, inout, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -954,9 +954,9 @@
                 parseFieldInitializerOpt(interface, interface, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -982,9 +982,9 @@
                 parseFieldInitializerOpt(is, is, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1006,9 +1006,9 @@
                 parseFieldInitializerOpt(late, late, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1030,9 +1030,9 @@
                 parseFieldInitializerOpt(library, library, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1054,9 +1054,9 @@
                 parseFieldInitializerOpt(mixin, mixin, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1078,9 +1078,9 @@
                 parseFieldInitializerOpt(native, native, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1106,9 +1106,9 @@
                 parseFieldInitializerOpt(new, new, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1134,9 +1134,9 @@
                 parseFieldInitializerOpt(null, null, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1158,9 +1158,9 @@
                 parseFieldInitializerOpt(of, of, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1182,9 +1182,9 @@
                 parseFieldInitializerOpt(on, on, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1207,9 +1207,9 @@
                 parseFieldInitializerOpt(operator, operator, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1231,9 +1231,9 @@
                 parseFieldInitializerOpt(out, out, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1255,9 +1255,9 @@
                 parseFieldInitializerOpt(part, part, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1279,9 +1279,9 @@
                 parseFieldInitializerOpt(patch, patch, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1303,9 +1303,9 @@
                 parseFieldInitializerOpt(required, required, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1331,9 +1331,9 @@
                 parseFieldInitializerOpt(rethrow, rethrow, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1359,9 +1359,9 @@
                 parseFieldInitializerOpt(return, return, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1384,9 +1384,9 @@
                 parseFieldInitializerOpt(set, set, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1408,9 +1408,9 @@
                 parseFieldInitializerOpt(show, show, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1432,9 +1432,9 @@
                 parseFieldInitializerOpt(source, source, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1456,9 +1456,9 @@
                 parseFieldInitializerOpt(static, static, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1483,9 +1483,9 @@
                   parseFieldInitializerOpt(super, super, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                     listener: beginFieldInitializer(=)
                     parseExpression(=)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                     listener: endFieldInitializer(=, ;)
@@ -1511,9 +1511,9 @@
                 parseFieldInitializerOpt(switch, switch, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1535,9 +1535,9 @@
                 parseFieldInitializerOpt(sync, sync, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1562,9 +1562,9 @@
                   parseFieldInitializerOpt(this, this, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                     listener: beginFieldInitializer(=)
                     parseExpression(=)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                     listener: endFieldInitializer(=, ;)
@@ -1590,9 +1590,9 @@
                 parseFieldInitializerOpt(throw, throw, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1618,9 +1618,9 @@
                 parseFieldInitializerOpt(true, true, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1646,9 +1646,9 @@
                 parseFieldInitializerOpt(try, try, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1670,9 +1670,9 @@
                 parseFieldInitializerOpt(typedef, typedef, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1698,9 +1698,9 @@
                 parseFieldInitializerOpt(var, var, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1726,9 +1726,9 @@
                 parseFieldInitializerOpt(void, void, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1754,9 +1754,9 @@
                 parseFieldInitializerOpt(while, while, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1782,9 +1782,9 @@
                 parseFieldInitializerOpt(with, with, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -1806,9 +1806,9 @@
                 parseFieldInitializerOpt(yield, yield, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

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 697889a..2514598 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
@@ -74,9 +74,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -87,9 +87,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -101,9 +101,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -117,9 +117,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -134,9 +134,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -147,18 +147,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(abstract, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -218,9 +218,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -231,9 +231,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -245,9 +245,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -261,9 +261,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -278,9 +278,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -291,18 +291,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(as, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -366,9 +366,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -379,9 +379,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -393,9 +393,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -409,16 +409,16 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseAssert(return, Assert.Expression)
                                   listener: beginAssert(assert, Assert.Expression)
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -429,9 +429,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -439,9 +439,9 @@
                                     listener: handleRecoverableError(AssertAsExpression, assert, assert)
                                   listener: endAssert(assert, Assert.Expression, (, null, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -501,9 +501,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -514,9 +514,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -528,9 +528,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -544,9 +544,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -561,9 +561,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -574,18 +574,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(async, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -645,9 +645,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -658,9 +658,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -672,9 +672,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -688,12 +688,12 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
                               inPlainSync()
                               looksLikeAwaitExpression(return, AwaitOrYieldContext.UnaryExpression)
                                 looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
-                              parsePrimary(return, expression)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -708,9 +708,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -721,18 +721,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(await, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -796,9 +796,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -809,9 +809,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -823,9 +823,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -839,9 +839,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -880,16 +880,16 @@
                           looksLikeLocalFunction(()
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                                      parseParenthesizedExpressionOrRecordLiteral(;, null)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -900,18 +900,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         ensureCloseParen(1, ()
                                         listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -974,9 +974,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -987,9 +987,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1001,9 +1001,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1017,9 +1017,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -1033,9 +1033,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -1046,18 +1046,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(case, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -1121,9 +1121,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1134,9 +1134,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1148,9 +1148,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1164,9 +1164,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -1180,9 +1180,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -1193,18 +1193,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(catch, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -1268,9 +1268,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1281,9 +1281,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1295,9 +1295,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1311,9 +1311,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -1327,9 +1327,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -1340,18 +1340,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(class, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -1415,9 +1415,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1428,9 +1428,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1442,9 +1442,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1458,17 +1458,17 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseConstExpression(return)
                                   listener: beginConstLiteral(()
-                                  parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                  parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -1479,9 +1479,9 @@
                                                   listener: handleNoArguments(-)
                                                 listener: handleSend(x, -)
                                         listener: beginBinaryExpression(-)
-                                        parsePrecedenceExpression(-, 14, true)
-                                          parseUnaryExpression(-, true)
-                                            parsePrimary(-, expression)
+                                        parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                            parsePrimary(-, expression, ConstantPatternContext.none)
                                               parseLiteralInt(-)
                                                 listener: handleLiteralInt(1)
                                         listener: endBinaryExpression(-)
@@ -1491,9 +1491,9 @@
                                     listener: endRecordLiteral((, 1, const)
                                   listener: endConstLiteral(+)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -1557,9 +1557,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1570,9 +1570,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1584,9 +1584,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1600,9 +1600,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -1641,16 +1641,16 @@
                           looksLikeLocalFunction(()
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                                      parseParenthesizedExpressionOrRecordLiteral(;, null)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -1661,18 +1661,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         ensureCloseParen(1, ()
                                         listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -1731,9 +1731,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1744,9 +1744,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1758,9 +1758,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1774,9 +1774,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -1791,9 +1791,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1804,18 +1804,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(covariant, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -1879,9 +1879,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1892,9 +1892,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1906,9 +1906,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1922,9 +1922,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -1938,9 +1938,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -1951,18 +1951,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(default, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -2022,9 +2022,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2035,9 +2035,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2049,9 +2049,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2065,9 +2065,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -2082,9 +2082,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2095,18 +2095,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(deferred, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -2170,9 +2170,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2183,9 +2183,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2197,9 +2197,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2213,9 +2213,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -2247,16 +2247,16 @@
                                 looksLikeLocalFunction(()
                                 parseExpressionStatement(do)
                                   parseExpression(do)
-                                    parsePrecedenceExpression(do, 1, true)
-                                      parseUnaryExpression(do, true)
-                                        parsePrimary(do, expression)
-                                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do)
-                                            parseParenthesizedExpressionOrRecordLiteral(do, null)
+                                    parsePrecedenceExpression(do, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(do, true, ConstantPatternContext.none)
+                                        parsePrimary(do, expression, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionOrRecordLiteral(do, null, ConstantPatternContext.none)
                                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                                               parseExpression(()
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()
@@ -2267,18 +2267,18 @@
                                                             listener: handleNoArguments(-)
                                                           listener: handleSend(x, -)
                                                   listener: beginBinaryExpression(-)
-                                                  parsePrecedenceExpression(-, 14, true)
-                                                    parseUnaryExpression(-, true)
-                                                      parsePrimary(-, expression)
+                                                  parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                      parsePrimary(-, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(-)
                                                           listener: handleLiteralInt(1)
                                                   listener: endBinaryExpression(-)
                                               ensureCloseParen(1, ()
                                               listener: endParenthesizedExpression(()
                                       listener: beginBinaryExpression(+)
-                                      parsePrecedenceExpression(+, 14, true)
-                                        parseUnaryExpression(+, true)
-                                          parsePrimary(+, expression)
+                                      parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                          parsePrimary(+, expression, ConstantPatternContext.none)
                                             parseLiteralInt(+)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(+)
@@ -2294,9 +2294,9 @@
                           rewriter()
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSend((, expression)
                                       isNextIdentifier(()
                                       ensureIdentifier((, expression)
@@ -2368,9 +2368,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2381,9 +2381,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2395,9 +2395,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2411,9 +2411,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -2428,9 +2428,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2441,18 +2441,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(dynamic, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -2516,9 +2516,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2529,9 +2529,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2543,9 +2543,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2559,9 +2559,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -2588,9 +2588,9 @@
                           looksLikeLocalFunction(else)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     inPlainSync()
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -2618,16 +2618,16 @@
                           looksLikeLocalFunction(()
                           parseExpressionStatement(else)
                             parseExpression(else)
-                              parsePrecedenceExpression(else, 1, true)
-                                parseUnaryExpression(else, true)
-                                  parsePrimary(else, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else)
-                                      parseParenthesizedExpressionOrRecordLiteral(else, null)
+                              parsePrecedenceExpression(else, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(else, true, ConstantPatternContext.none)
+                                  parsePrimary(else, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(else, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -2638,18 +2638,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         ensureCloseParen(1, ()
                                         listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -2712,9 +2712,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2725,9 +2725,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2739,9 +2739,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2755,9 +2755,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -2771,9 +2771,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -2784,18 +2784,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(enum, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -2855,9 +2855,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2868,9 +2868,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2882,9 +2882,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2898,9 +2898,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -2915,9 +2915,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2928,18 +2928,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(export, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -3003,9 +3003,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3016,9 +3016,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3030,9 +3030,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -3046,9 +3046,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -3062,9 +3062,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -3075,18 +3075,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(extends, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -3146,9 +3146,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3159,9 +3159,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3173,9 +3173,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -3189,9 +3189,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -3206,9 +3206,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -3219,18 +3219,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(extension, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -3290,9 +3290,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3303,9 +3303,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3317,9 +3317,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -3333,9 +3333,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -3350,9 +3350,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -3363,18 +3363,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(external, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -3434,9 +3434,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3447,9 +3447,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3461,9 +3461,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -3477,9 +3477,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -3494,9 +3494,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -3507,18 +3507,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(factory, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -3582,9 +3582,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3595,9 +3595,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3609,9 +3609,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -3625,9 +3625,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralBool(return)
                                   listener: handleLiteralBool(false)
                             parseArgumentOrIndexStar(false, Instance of 'NoTypeParamOrArg', false)
@@ -3636,9 +3636,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -3649,18 +3649,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                               listener: handleSend((, ))
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -3724,9 +3724,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3737,9 +3737,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3751,9 +3751,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -3767,9 +3767,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -3820,9 +3820,9 @@
                         looksLikeLocalFunction(x)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -3833,9 +3833,9 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
@@ -3852,9 +3852,9 @@
                           looksLikeLocalFunction())
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
@@ -3881,13 +3881,13 @@
                           looksLikeLocalFunction(+)
                           parseExpressionStatement())
                             parseExpression())
-                              parsePrecedenceExpression(), 1, true)
-                                parseUnaryExpression(), true)
+                              parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(), true, ConstantPatternContext.none)
                                   rewriteAndRecover(), UnsupportedPrefixPlus, )
                                     reportRecoverableError(+, UnsupportedPrefixPlus)
                                       listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                     rewriter()
-                                  parsePrimary(), expression)
+                                  parsePrimary(), expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
                                         isNextIdentifier())
@@ -3898,9 +3898,9 @@
                                           listener: handleNoArguments(+)
                                         listener: handleSend(, +)
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -3963,9 +3963,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -3976,9 +3976,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -3990,9 +3990,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4006,9 +4006,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -4022,9 +4022,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -4035,18 +4035,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(finally, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -4110,9 +4110,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4123,9 +4123,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -4137,9 +4137,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4153,9 +4153,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -4184,9 +4184,9 @@
                             parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, ForPartsContext(null))
                         parseForLoopPartsMid((, null, for)
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -4197,9 +4197,9 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
@@ -4212,9 +4212,9 @@
                               rewriter()
                             parseExpressionStatement(;)
                               parseExpression(;)
-                                parsePrecedenceExpression(;, 1, true)
-                                  parseUnaryExpression(;, true)
-                                    parsePrimary(;, expression)
+                                parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                    parsePrimary(;, expression, ConstantPatternContext.none)
                                       parseSend(;, expression)
                                         isNextIdentifier(;)
                                         ensureIdentifier(;, expression)
@@ -4240,13 +4240,13 @@
                                   looksLikeLocalFunction(+)
                                   parseExpressionStatement())
                                     parseExpression())
-                                      parsePrecedenceExpression(), 1, true)
-                                        parseUnaryExpression(), true)
+                                      parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(), true, ConstantPatternContext.none)
                                           rewriteAndRecover(), UnsupportedPrefixPlus, )
                                             reportRecoverableError(+, UnsupportedPrefixPlus)
                                               listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                             rewriter()
-                                          parsePrimary(), expression)
+                                          parsePrimary(), expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(), expression)
                                               parseSend(), expression)
                                                 isNextIdentifier())
@@ -4257,9 +4257,9 @@
                                                   listener: handleNoArguments(+)
                                                 listener: handleSend(, +)
                                         listener: beginBinaryExpression(+)
-                                        parsePrecedenceExpression(+, 14, true)
-                                          parseUnaryExpression(+, true)
-                                            parsePrimary(+, expression)
+                                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                            parsePrimary(+, expression, ConstantPatternContext.none)
                                               parseLiteralInt(+)
                                                 listener: handleLiteralInt(1)
                                         listener: endBinaryExpression(+)
@@ -4320,9 +4320,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4333,9 +4333,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -4347,9 +4347,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4363,9 +4363,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -4380,9 +4380,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -4393,18 +4393,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(Function, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -4465,9 +4465,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4478,9 +4478,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -4492,9 +4492,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4508,9 +4508,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -4525,9 +4525,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -4538,18 +4538,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(get, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -4609,9 +4609,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4622,9 +4622,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -4636,9 +4636,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4652,9 +4652,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -4669,9 +4669,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -4682,18 +4682,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(hide, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -4757,9 +4757,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4770,9 +4770,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -4784,9 +4784,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4800,9 +4800,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -4829,9 +4829,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4842,9 +4842,9 @@
                                           listener: handleNoArguments(-)
                                         listener: handleSend(x, -)
                                 listener: beginBinaryExpression(-)
-                                parsePrecedenceExpression(-, 14, true)
-                                  parseUnaryExpression(-, true)
-                                    parsePrimary(-, expression)
+                                parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                       parseLiteralInt(-)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(-)
@@ -4858,13 +4858,13 @@
                                 looksLikeLocalFunction(+)
                                 parseExpressionStatement())
                                   parseExpression())
-                                    parsePrecedenceExpression(), 1, true)
-                                      parseUnaryExpression(), true)
+                                    parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(), true, ConstantPatternContext.none)
                                         rewriteAndRecover(), UnsupportedPrefixPlus, )
                                           reportRecoverableError(+, UnsupportedPrefixPlus)
                                             listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                           rewriter()
-                                        parsePrimary(), expression)
+                                        parsePrimary(), expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(), expression)
                                             parseSend(), expression)
                                               isNextIdentifier())
@@ -4875,9 +4875,9 @@
                                                 listener: handleNoArguments(+)
                                               listener: handleSend(, +)
                                       listener: beginBinaryExpression(+)
-                                      parsePrecedenceExpression(+, 14, true)
-                                        parseUnaryExpression(+, true)
-                                          parsePrimary(+, expression)
+                                      parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                          parsePrimary(+, expression, ConstantPatternContext.none)
                                             parseLiteralInt(+)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(+)
@@ -4938,9 +4938,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -4951,9 +4951,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -4965,9 +4965,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -4981,9 +4981,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -4998,9 +4998,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -5011,18 +5011,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(implements, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -5082,9 +5082,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5095,9 +5095,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -5109,9 +5109,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -5125,9 +5125,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -5142,9 +5142,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -5155,18 +5155,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(import, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -5230,9 +5230,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5243,9 +5243,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -5257,9 +5257,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -5273,9 +5273,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -5289,9 +5289,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -5302,18 +5302,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(in, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -5373,9 +5373,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5386,9 +5386,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -5400,9 +5400,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -5416,9 +5416,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -5433,9 +5433,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -5446,18 +5446,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(inout, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -5517,9 +5517,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5530,9 +5530,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -5544,9 +5544,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -5560,9 +5560,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -5577,9 +5577,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -5590,18 +5590,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(interface, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -5665,9 +5665,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5678,9 +5678,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -5692,9 +5692,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -5708,9 +5708,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -5761,13 +5761,13 @@
                           looksLikeLocalFunction(+)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
                                   rewriteAndRecover(;, UnsupportedPrefixPlus, )
                                     reportRecoverableError(+, UnsupportedPrefixPlus)
                                       listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                     rewriter()
-                                  parsePrimary(;, expression)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(;, expression)
                                       parseSend(;, expression)
                                         isNextIdentifier(;)
@@ -5778,9 +5778,9 @@
                                           listener: handleNoArguments(+)
                                         listener: handleSend(, +)
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -5839,9 +5839,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5852,9 +5852,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -5866,9 +5866,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -5882,9 +5882,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -5899,9 +5899,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -5912,18 +5912,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(late, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -5983,9 +5983,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -5996,9 +5996,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6010,9 +6010,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6026,9 +6026,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -6043,9 +6043,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -6056,18 +6056,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(library, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -6127,9 +6127,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -6140,9 +6140,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6154,9 +6154,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6170,9 +6170,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -6187,9 +6187,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -6200,18 +6200,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(mixin, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -6271,9 +6271,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -6284,9 +6284,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6298,9 +6298,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6314,9 +6314,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -6331,9 +6331,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -6344,18 +6344,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(native, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -6419,9 +6419,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -6432,9 +6432,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6446,9 +6446,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6462,9 +6462,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseNewExpression(return)
                                   isNextIdentifier(new)
                                   listener: beginNewExpression(new)
@@ -6484,9 +6484,9 @@
                                     parseArgumentsRest(()
                                       listener: beginArguments(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -6497,18 +6497,18 @@
                                                     listener: handleNoArguments(-)
                                                   listener: handleSend(x, -)
                                           listener: beginBinaryExpression(-)
-                                          parsePrecedenceExpression(-, 14, true)
-                                            parseUnaryExpression(-, true)
-                                              parsePrimary(-, expression)
+                                          parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                              parsePrimary(-, expression, ConstantPatternContext.none)
                                                 parseLiteralInt(-)
                                                   listener: handleLiteralInt(1)
                                           listener: endBinaryExpression(-)
                                       listener: endArguments(1, (, ))
                                   listener: endNewExpression(new)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -6572,9 +6572,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -6585,9 +6585,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6599,9 +6599,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6615,9 +6615,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralNull(return)
                                   listener: handleLiteralNull(null)
                             parseArgumentOrIndexStar(null, Instance of 'NoTypeParamOrArg', false)
@@ -6626,9 +6626,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -6639,18 +6639,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                               listener: handleSend((, ))
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -6710,9 +6710,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -6723,9 +6723,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6737,9 +6737,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6753,9 +6753,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -6770,9 +6770,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -6783,18 +6783,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(of, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -6854,9 +6854,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -6867,9 +6867,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -6881,9 +6881,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -6897,9 +6897,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -6914,9 +6914,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -6927,18 +6927,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(on, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7000,9 +7000,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7013,9 +7013,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7027,9 +7027,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7043,9 +7043,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -7060,9 +7060,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -7073,18 +7073,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(operator, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7144,9 +7144,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7157,9 +7157,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7171,9 +7171,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7187,9 +7187,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -7204,9 +7204,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -7217,18 +7217,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(out, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7288,9 +7288,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7301,9 +7301,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7315,9 +7315,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7331,9 +7331,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -7348,9 +7348,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -7361,18 +7361,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(part, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7432,9 +7432,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7445,9 +7445,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7459,9 +7459,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7475,9 +7475,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -7492,9 +7492,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -7505,18 +7505,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(patch, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7576,9 +7576,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7589,9 +7589,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7603,9 +7603,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7619,9 +7619,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -7636,9 +7636,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -7649,18 +7649,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(required, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7724,9 +7724,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7737,9 +7737,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7751,9 +7751,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7767,9 +7767,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -7783,9 +7783,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -7796,18 +7796,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(rethrow, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -7871,9 +7871,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -7884,9 +7884,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -7898,9 +7898,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -7914,20 +7914,20 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
-                                parsePrimary(return, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                    parseParenthesizedExpressionOrRecordLiteral(return, null)
+                                parsePrimary(return, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -7938,18 +7938,18 @@
                                                     listener: handleNoArguments(-)
                                                   listener: handleSend(x, -)
                                           listener: beginBinaryExpression(-)
-                                          parsePrecedenceExpression(-, 14, true)
-                                            parseUnaryExpression(-, true)
-                                              parsePrimary(-, expression)
+                                          parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                              parsePrimary(-, expression, ConstantPatternContext.none)
                                                 parseLiteralInt(-)
                                                   listener: handleLiteralInt(1)
                                           listener: endBinaryExpression(-)
                                       ensureCloseParen(1, ()
                                       listener: endParenthesizedExpression(()
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -8010,9 +8010,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8023,9 +8023,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -8037,9 +8037,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -8053,9 +8053,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -8070,9 +8070,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -8083,18 +8083,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(set, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -8154,9 +8154,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8167,9 +8167,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -8181,9 +8181,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -8197,9 +8197,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -8214,9 +8214,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -8227,18 +8227,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(show, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -8298,9 +8298,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8311,9 +8311,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -8325,9 +8325,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -8341,9 +8341,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -8358,9 +8358,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -8371,18 +8371,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(source, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -8442,9 +8442,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8455,9 +8455,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -8469,9 +8469,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -8485,9 +8485,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -8502,9 +8502,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -8515,18 +8515,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(static, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -8613,9 +8613,9 @@
                           ensureParenthesizedCondition(if, allowCase: false)
                             parseExpressionInParenthesisRest((, allowCase: false)
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
                                           isNextIdentifier(()
@@ -8626,9 +8626,9 @@
                                             listener: handleNoArguments(==)
                                           listener: handleSend(x, ==)
                                   listener: beginBinaryExpression(==)
-                                  parsePrecedenceExpression(==, 8, true)
-                                    parseUnaryExpression(==, true)
-                                      parsePrimary(==, expression)
+                                  parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                      parsePrimary(==, expression, ConstantPatternContext.none)
                                         parseLiteralInt(==)
                                           listener: handleLiteralInt(0)
                                   listener: endBinaryExpression(==)
@@ -8640,9 +8640,9 @@
                               parseReturnStatement())
                                 listener: beginReturnStatement(return)
                                 parseExpression(return)
-                                  parsePrecedenceExpression(return, 1, true)
-                                    parseUnaryExpression(return, true)
-                                      parsePrimary(return, expression)
+                                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                      parsePrimary(return, expression, ConstantPatternContext.none)
                                         parseLiteralInt(return)
                                           listener: handleLiteralInt(42)
                                 ensureSemicolon(42)
@@ -8656,9 +8656,9 @@
                         parseReturnStatement(;)
                           listener: beginReturnStatement(return)
                           parseExpression(return)
-                            parsePrecedenceExpression(return, 1, true)
-                              parseUnaryExpression(return, true)
-                                parsePrimary(return, expression)
+                            parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                parsePrimary(return, expression, ConstantPatternContext.none)
                                   parseSuperExpression(return, expression)
                                     listener: handleSuperExpression(super, expression)
                                     listener: handleNoTypeArguments(()
@@ -8666,9 +8666,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -8679,18 +8679,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                     listener: handleSend(super, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(+)
@@ -8754,9 +8754,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8767,9 +8767,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -8781,9 +8781,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -8797,9 +8797,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -8826,9 +8826,9 @@
                         ensureParenthesizedCondition(switch, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8839,9 +8839,9 @@
                                           listener: handleNoArguments(-)
                                         listener: handleSend(x, -)
                                 listener: beginBinaryExpression(-)
-                                parsePrecedenceExpression(-, 14, true)
-                                  parseUnaryExpression(-, true)
-                                    parsePrimary(-, expression)
+                                parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                       parseLiteralInt(-)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(-)
@@ -8866,13 +8866,13 @@
                           looksLikeLocalFunction(+)
                           parseExpressionStatement(})
                             parseExpression(})
-                              parsePrecedenceExpression(}, 1, true)
-                                parseUnaryExpression(}, true)
+                              parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(}, true, ConstantPatternContext.none)
                                   rewriteAndRecover(}, UnsupportedPrefixPlus, )
                                     reportRecoverableError(+, UnsupportedPrefixPlus)
                                       listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                     rewriter()
-                                  parsePrimary(}, expression)
+                                  parsePrimary(}, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(}, expression)
                                       parseSend(}, expression)
                                         isNextIdentifier(})
@@ -8883,9 +8883,9 @@
                                           listener: handleNoArguments(+)
                                         listener: handleSend(, +)
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -8944,9 +8944,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -8957,9 +8957,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -8971,9 +8971,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -8987,9 +8987,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -9004,9 +9004,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -9017,18 +9017,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(sync, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -9115,9 +9115,9 @@
                           ensureParenthesizedCondition(if, allowCase: false)
                             parseExpressionInParenthesisRest((, allowCase: false)
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
                                           isNextIdentifier(()
@@ -9128,9 +9128,9 @@
                                             listener: handleNoArguments(==)
                                           listener: handleSend(x, ==)
                                   listener: beginBinaryExpression(==)
-                                  parsePrecedenceExpression(==, 8, true)
-                                    parseUnaryExpression(==, true)
-                                      parsePrimary(==, expression)
+                                  parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                      parsePrimary(==, expression, ConstantPatternContext.none)
                                         parseLiteralInt(==)
                                           listener: handleLiteralInt(0)
                                   listener: endBinaryExpression(==)
@@ -9142,9 +9142,9 @@
                               parseReturnStatement())
                                 listener: beginReturnStatement(return)
                                 parseExpression(return)
-                                  parsePrecedenceExpression(return, 1, true)
-                                    parseUnaryExpression(return, true)
-                                      parsePrimary(return, expression)
+                                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                      parsePrimary(return, expression, ConstantPatternContext.none)
                                         parseLiteralInt(return)
                                           listener: handleLiteralInt(42)
                                 ensureSemicolon(42)
@@ -9158,9 +9158,9 @@
                         parseReturnStatement(;)
                           listener: beginReturnStatement(return)
                           parseExpression(return)
-                            parsePrecedenceExpression(return, 1, true)
-                              parseUnaryExpression(return, true)
-                                parsePrimary(return, expression)
+                            parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                parsePrimary(return, expression, ConstantPatternContext.none)
                                   parseThisExpression(return, expression)
                                     listener: handleThisExpression(this, expression)
                                     listener: handleNoTypeArguments(()
@@ -9168,9 +9168,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -9181,18 +9181,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                     listener: handleSend(this, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(+)
@@ -9256,9 +9256,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -9269,9 +9269,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -9283,9 +9283,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -9301,16 +9301,16 @@
                         parseExpression(return)
                           parseThrowExpression(return, true)
                             parseExpression(throw)
-                              parsePrecedenceExpression(throw, 1, true)
-                                parseUnaryExpression(throw, true)
-                                  parsePrimary(throw, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw)
-                                      parseParenthesizedExpressionOrRecordLiteral(throw, null)
+                              parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                  parsePrimary(throw, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(throw, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -9321,18 +9321,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         ensureCloseParen(1, ()
                                         listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -9397,9 +9397,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -9410,9 +9410,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -9424,9 +9424,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -9440,9 +9440,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralBool(return)
                                   listener: handleLiteralBool(true)
                             parseArgumentOrIndexStar(true, Instance of 'NoTypeParamOrArg', false)
@@ -9451,9 +9451,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -9464,18 +9464,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                               listener: handleSend((, ))
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -9539,9 +9539,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -9552,9 +9552,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -9566,9 +9566,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -9582,9 +9582,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -9629,16 +9629,16 @@
                           looksLikeLocalFunction(()
                           parseExpressionStatement(})
                             parseExpression(})
-                              parsePrecedenceExpression(}, 1, true)
-                                parseUnaryExpression(}, true)
-                                  parsePrimary(}, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(})
-                                      parseParenthesizedExpressionOrRecordLiteral(}, null)
+                              parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(}, true, ConstantPatternContext.none)
+                                  parsePrimary(}, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(}, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(}, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -9649,18 +9649,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         ensureCloseParen(1, ()
                                         listener: endParenthesizedExpression(()
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -9719,9 +9719,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -9732,9 +9732,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -9746,9 +9746,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -9762,9 +9762,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -9779,9 +9779,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -9792,18 +9792,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(typedef, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -9867,9 +9867,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -9880,9 +9880,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -9894,9 +9894,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -9910,9 +9910,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -9963,9 +9963,9 @@
                         looksLikeLocalFunction(x)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -9976,9 +9976,9 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
@@ -9995,9 +9995,9 @@
                           looksLikeLocalFunction())
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
@@ -10024,13 +10024,13 @@
                           looksLikeLocalFunction(+)
                           parseExpressionStatement())
                             parseExpression())
-                              parsePrecedenceExpression(), 1, true)
-                                parseUnaryExpression(), true)
+                              parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(), true, ConstantPatternContext.none)
                                   rewriteAndRecover(), UnsupportedPrefixPlus, )
                                     reportRecoverableError(+, UnsupportedPrefixPlus)
                                       listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                     rewriter()
-                                  parsePrimary(), expression)
+                                  parsePrimary(), expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
                                         isNextIdentifier())
@@ -10041,9 +10041,9 @@
                                           listener: handleNoArguments(+)
                                         listener: handleSend(, +)
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -10106,9 +10106,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -10119,9 +10119,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -10133,9 +10133,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -10149,9 +10149,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -10203,9 +10203,9 @@
                         looksLikeLocalFunction(x)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -10216,9 +10216,9 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
@@ -10235,9 +10235,9 @@
                           looksLikeLocalFunction())
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
@@ -10264,13 +10264,13 @@
                           looksLikeLocalFunction(+)
                           parseExpressionStatement())
                             parseExpression())
-                              parsePrecedenceExpression(), 1, true)
-                                parseUnaryExpression(), true)
+                              parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(), true, ConstantPatternContext.none)
                                   rewriteAndRecover(), UnsupportedPrefixPlus, )
                                     reportRecoverableError(+, UnsupportedPrefixPlus)
                                       listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                     rewriter()
-                                  parsePrimary(), expression)
+                                  parsePrimary(), expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
                                         isNextIdentifier())
@@ -10281,9 +10281,9 @@
                                           listener: handleNoArguments(+)
                                         listener: handleSend(, +)
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -10346,9 +10346,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -10359,9 +10359,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -10373,9 +10373,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -10389,9 +10389,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -10418,9 +10418,9 @@
                         ensureParenthesizedCondition(while, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -10431,9 +10431,9 @@
                                           listener: handleNoArguments(-)
                                         listener: handleSend(x, -)
                                 listener: beginBinaryExpression(-)
-                                parsePrecedenceExpression(-, 14, true)
-                                  parseUnaryExpression(-, true)
-                                    parsePrimary(-, expression)
+                                parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                       parseLiteralInt(-)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(-)
@@ -10447,13 +10447,13 @@
                                 looksLikeLocalFunction(+)
                                 parseExpressionStatement())
                                   parseExpression())
-                                    parsePrecedenceExpression(), 1, true)
-                                      parseUnaryExpression(), true)
+                                    parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(), true, ConstantPatternContext.none)
                                         rewriteAndRecover(), UnsupportedPrefixPlus, )
                                           reportRecoverableError(+, UnsupportedPrefixPlus)
                                             listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                           rewriter()
-                                        parsePrimary(), expression)
+                                        parsePrimary(), expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(), expression)
                                             parseSend(), expression)
                                               isNextIdentifier())
@@ -10464,9 +10464,9 @@
                                                 listener: handleNoArguments(+)
                                               listener: handleSend(, +)
                                       listener: beginBinaryExpression(+)
-                                      parsePrecedenceExpression(+, 14, true)
-                                        parseUnaryExpression(+, true)
-                                          parsePrimary(+, expression)
+                                      parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                          parsePrimary(+, expression, ConstantPatternContext.none)
                                             parseLiteralInt(+)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(+)
@@ -10531,9 +10531,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -10544,9 +10544,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -10558,9 +10558,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -10574,9 +10574,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSend(return, expression)
                                   isNextIdentifier(return)
@@ -10590,9 +10590,9 @@
                                       parseArgumentsRest(()
                                         listener: beginArguments(()
                                         parseExpression(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
                                                     isNextIdentifier(()
@@ -10603,18 +10603,18 @@
                                                       listener: handleNoArguments(-)
                                                     listener: handleSend(x, -)
                                             listener: beginBinaryExpression(-)
-                                            parsePrecedenceExpression(-, 14, true)
-                                              parseUnaryExpression(-, true)
-                                                parsePrimary(-, expression)
+                                            parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                parsePrimary(-, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(-)
                                                     listener: handleLiteralInt(1)
                                             listener: endBinaryExpression(-)
                                         listener: endArguments(1, (, ))
                                   listener: handleSend(with, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)
@@ -10674,9 +10674,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -10687,9 +10687,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -10701,9 +10701,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -10717,9 +10717,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
@@ -10734,9 +10734,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -10747,18 +10747,18 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
                                           listener: endArguments(1, (, ))
                                     listener: handleSend(yield, +)
                             listener: beginBinaryExpression(+)
-                            parsePrecedenceExpression(+, 14, true)
-                              parseUnaryExpression(+, true)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                                     listener: handleLiteralInt(1)
                             listener: endBinaryExpression(+)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter.dart.intertwined.expect
index 92be491..b81d11f 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter.dart.intertwined.expect
@@ -118,9 +118,9 @@
                     listener: handleIdentifier(abstract, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -214,9 +214,9 @@
                     listener: handleIdentifier(abstract, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -266,9 +266,9 @@
                     listener: handleIdentifier(abstract, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -402,9 +402,9 @@
                     listener: handleIdentifier(as, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -498,9 +498,9 @@
                     listener: handleIdentifier(as, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -550,9 +550,9 @@
                     listener: handleIdentifier(as, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -689,9 +689,9 @@
                     listener: handleIdentifier(assert, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -787,9 +787,9 @@
                     listener: handleIdentifier(assert, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -840,9 +840,9 @@
                     listener: handleIdentifier(assert, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -976,9 +976,9 @@
                     listener: handleIdentifier(async, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1072,9 +1072,9 @@
                     listener: handleIdentifier(async, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1124,9 +1124,9 @@
                     listener: handleIdentifier(async, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1260,9 +1260,9 @@
                     listener: handleIdentifier(await, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1356,9 +1356,9 @@
                     listener: handleIdentifier(await, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1408,9 +1408,9 @@
                     listener: handleIdentifier(await, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1547,9 +1547,9 @@
                     listener: handleIdentifier(break, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1645,9 +1645,9 @@
                     listener: handleIdentifier(break, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1698,9 +1698,9 @@
                     listener: handleIdentifier(break, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1837,9 +1837,9 @@
                     listener: handleIdentifier(case, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1935,9 +1935,9 @@
                     listener: handleIdentifier(case, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1988,9 +1988,9 @@
                     listener: handleIdentifier(case, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2127,9 +2127,9 @@
                     listener: handleIdentifier(catch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2225,9 +2225,9 @@
                     listener: handleIdentifier(catch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2278,9 +2278,9 @@
                     listener: handleIdentifier(catch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2417,9 +2417,9 @@
                     listener: handleIdentifier(class, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2515,9 +2515,9 @@
                     listener: handleIdentifier(class, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2568,9 +2568,9 @@
                     listener: handleIdentifier(class, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2707,9 +2707,9 @@
                     listener: handleIdentifier(const, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2805,9 +2805,9 @@
                     listener: handleIdentifier(const, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2858,9 +2858,9 @@
                     listener: handleIdentifier(const, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2997,9 +2997,9 @@
                     listener: handleIdentifier(continue, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3095,9 +3095,9 @@
                     listener: handleIdentifier(continue, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3148,9 +3148,9 @@
                     listener: handleIdentifier(continue, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3284,9 +3284,9 @@
                     listener: handleIdentifier(covariant, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3380,9 +3380,9 @@
                     listener: handleIdentifier(covariant, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3432,9 +3432,9 @@
                     listener: handleIdentifier(covariant, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3571,9 +3571,9 @@
                     listener: handleIdentifier(default, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3669,9 +3669,9 @@
                     listener: handleIdentifier(default, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3722,9 +3722,9 @@
                     listener: handleIdentifier(default, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3858,9 +3858,9 @@
                     listener: handleIdentifier(deferred, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3954,9 +3954,9 @@
                     listener: handleIdentifier(deferred, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4006,9 +4006,9 @@
                     listener: handleIdentifier(deferred, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4145,9 +4145,9 @@
                     listener: handleIdentifier(do, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4243,9 +4243,9 @@
                     listener: handleIdentifier(do, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4296,9 +4296,9 @@
                     listener: handleIdentifier(do, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4432,9 +4432,9 @@
                     listener: handleIdentifier(dynamic, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4528,9 +4528,9 @@
                     listener: handleIdentifier(dynamic, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4580,9 +4580,9 @@
                     listener: handleIdentifier(dynamic, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4719,9 +4719,9 @@
                     listener: handleIdentifier(else, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4817,9 +4817,9 @@
                     listener: handleIdentifier(else, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4870,9 +4870,9 @@
                     listener: handleIdentifier(else, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5009,9 +5009,9 @@
                     listener: handleIdentifier(enum, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5107,9 +5107,9 @@
                     listener: handleIdentifier(enum, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5160,9 +5160,9 @@
                     listener: handleIdentifier(enum, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5296,9 +5296,9 @@
                     listener: handleIdentifier(export, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5392,9 +5392,9 @@
                     listener: handleIdentifier(export, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5444,9 +5444,9 @@
                     listener: handleIdentifier(export, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5583,9 +5583,9 @@
                     listener: handleIdentifier(extends, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5681,9 +5681,9 @@
                     listener: handleIdentifier(extends, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5734,9 +5734,9 @@
                     listener: handleIdentifier(extends, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5870,9 +5870,9 @@
                     listener: handleIdentifier(extension, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5966,9 +5966,9 @@
                     listener: handleIdentifier(extension, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6018,9 +6018,9 @@
                     listener: handleIdentifier(extension, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6154,9 +6154,9 @@
                     listener: handleIdentifier(external, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6250,9 +6250,9 @@
                     listener: handleIdentifier(external, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6302,9 +6302,9 @@
                     listener: handleIdentifier(external, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6438,9 +6438,9 @@
                     listener: handleIdentifier(factory, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6534,9 +6534,9 @@
                     listener: handleIdentifier(factory, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6586,9 +6586,9 @@
                     listener: handleIdentifier(factory, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6725,9 +6725,9 @@
                     listener: handleIdentifier(false, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6823,9 +6823,9 @@
                     listener: handleIdentifier(false, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6876,9 +6876,9 @@
                     listener: handleIdentifier(false, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7015,9 +7015,9 @@
                     listener: handleIdentifier(final, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7113,9 +7113,9 @@
                     listener: handleIdentifier(final, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7166,9 +7166,9 @@
                     listener: handleIdentifier(final, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7305,9 +7305,9 @@
                     listener: handleIdentifier(finally, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7403,9 +7403,9 @@
                     listener: handleIdentifier(finally, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7456,9 +7456,9 @@
                     listener: handleIdentifier(finally, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7595,9 +7595,9 @@
                     listener: handleIdentifier(for, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7693,9 +7693,9 @@
                     listener: handleIdentifier(for, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7746,9 +7746,9 @@
                     listener: handleIdentifier(for, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7882,9 +7882,9 @@
                     listener: handleIdentifier(Function, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7978,9 +7978,9 @@
                     listener: handleIdentifier(Function, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8030,9 +8030,9 @@
                     listener: handleIdentifier(Function, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8166,9 +8166,9 @@
                     listener: handleIdentifier(get, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8262,9 +8262,9 @@
                     listener: handleIdentifier(get, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8314,9 +8314,9 @@
                     listener: handleIdentifier(get, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8450,9 +8450,9 @@
                     listener: handleIdentifier(hide, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8546,9 +8546,9 @@
                     listener: handleIdentifier(hide, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8598,9 +8598,9 @@
                     listener: handleIdentifier(hide, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8737,9 +8737,9 @@
                     listener: handleIdentifier(if, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8835,9 +8835,9 @@
                     listener: handleIdentifier(if, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8888,9 +8888,9 @@
                     listener: handleIdentifier(if, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9024,9 +9024,9 @@
                     listener: handleIdentifier(implements, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9120,9 +9120,9 @@
                     listener: handleIdentifier(implements, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9172,9 +9172,9 @@
                     listener: handleIdentifier(implements, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9308,9 +9308,9 @@
                     listener: handleIdentifier(import, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9404,9 +9404,9 @@
                     listener: handleIdentifier(import, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9456,9 +9456,9 @@
                     listener: handleIdentifier(import, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9595,9 +9595,9 @@
                     listener: handleIdentifier(in, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9693,9 +9693,9 @@
                     listener: handleIdentifier(in, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9746,9 +9746,9 @@
                     listener: handleIdentifier(in, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9882,9 +9882,9 @@
                     listener: handleIdentifier(inout, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9978,9 +9978,9 @@
                     listener: handleIdentifier(inout, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10030,9 +10030,9 @@
                     listener: handleIdentifier(inout, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10166,9 +10166,9 @@
                     listener: handleIdentifier(interface, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10262,9 +10262,9 @@
                     listener: handleIdentifier(interface, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10314,9 +10314,9 @@
                     listener: handleIdentifier(interface, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10453,9 +10453,9 @@
                     listener: handleIdentifier(is, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10551,9 +10551,9 @@
                     listener: handleIdentifier(is, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10604,9 +10604,9 @@
                     listener: handleIdentifier(is, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10740,9 +10740,9 @@
                     listener: handleIdentifier(late, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10836,9 +10836,9 @@
                     listener: handleIdentifier(late, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10888,9 +10888,9 @@
                     listener: handleIdentifier(late, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11024,9 +11024,9 @@
                     listener: handleIdentifier(library, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11120,9 +11120,9 @@
                     listener: handleIdentifier(library, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11172,9 +11172,9 @@
                     listener: handleIdentifier(library, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11308,9 +11308,9 @@
                     listener: handleIdentifier(mixin, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11404,9 +11404,9 @@
                     listener: handleIdentifier(mixin, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11456,9 +11456,9 @@
                     listener: handleIdentifier(mixin, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11592,9 +11592,9 @@
                     listener: handleIdentifier(native, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11688,9 +11688,9 @@
                     listener: handleIdentifier(native, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11740,9 +11740,9 @@
                     listener: handleIdentifier(native, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11879,9 +11879,9 @@
                     listener: handleIdentifier(new, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11977,9 +11977,9 @@
                     listener: handleIdentifier(new, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12030,9 +12030,9 @@
                     listener: handleIdentifier(new, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12169,9 +12169,9 @@
                     listener: handleIdentifier(null, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12267,9 +12267,9 @@
                     listener: handleIdentifier(null, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12320,9 +12320,9 @@
                     listener: handleIdentifier(null, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12456,9 +12456,9 @@
                     listener: handleIdentifier(of, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12552,9 +12552,9 @@
                     listener: handleIdentifier(of, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12604,9 +12604,9 @@
                     listener: handleIdentifier(of, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12740,9 +12740,9 @@
                     listener: handleIdentifier(on, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12836,9 +12836,9 @@
                     listener: handleIdentifier(on, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12888,9 +12888,9 @@
                     listener: handleIdentifier(on, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13024,9 +13024,9 @@
                     listener: handleIdentifier(operator, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13120,9 +13120,9 @@
                     listener: handleIdentifier(operator, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13172,9 +13172,9 @@
                     listener: handleIdentifier(operator, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13308,9 +13308,9 @@
                     listener: handleIdentifier(out, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13404,9 +13404,9 @@
                     listener: handleIdentifier(out, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13456,9 +13456,9 @@
                     listener: handleIdentifier(out, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13592,9 +13592,9 @@
                     listener: handleIdentifier(part, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13688,9 +13688,9 @@
                     listener: handleIdentifier(part, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13740,9 +13740,9 @@
                     listener: handleIdentifier(part, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13876,9 +13876,9 @@
                     listener: handleIdentifier(patch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13972,9 +13972,9 @@
                     listener: handleIdentifier(patch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14024,9 +14024,9 @@
                     listener: handleIdentifier(patch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14160,9 +14160,9 @@
                     listener: handleIdentifier(required, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14256,9 +14256,9 @@
                     listener: handleIdentifier(required, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14308,9 +14308,9 @@
                     listener: handleIdentifier(required, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14447,9 +14447,9 @@
                     listener: handleIdentifier(rethrow, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14545,9 +14545,9 @@
                     listener: handleIdentifier(rethrow, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14598,9 +14598,9 @@
                     listener: handleIdentifier(rethrow, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14737,9 +14737,9 @@
                     listener: handleIdentifier(return, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14835,9 +14835,9 @@
                     listener: handleIdentifier(return, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14888,9 +14888,9 @@
                     listener: handleIdentifier(return, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15024,9 +15024,9 @@
                     listener: handleIdentifier(set, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15120,9 +15120,9 @@
                     listener: handleIdentifier(set, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15172,9 +15172,9 @@
                     listener: handleIdentifier(set, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15308,9 +15308,9 @@
                     listener: handleIdentifier(show, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15404,9 +15404,9 @@
                     listener: handleIdentifier(show, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15456,9 +15456,9 @@
                     listener: handleIdentifier(show, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15592,9 +15592,9 @@
                     listener: handleIdentifier(source, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15688,9 +15688,9 @@
                     listener: handleIdentifier(source, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15740,9 +15740,9 @@
                     listener: handleIdentifier(source, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15876,9 +15876,9 @@
                     listener: handleIdentifier(static, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15972,9 +15972,9 @@
                     listener: handleIdentifier(static, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16024,9 +16024,9 @@
                     listener: handleIdentifier(static, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16163,9 +16163,9 @@
                     listener: handleIdentifier(super, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16261,9 +16261,9 @@
                     listener: handleIdentifier(super, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16314,9 +16314,9 @@
                     listener: handleIdentifier(super, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16453,9 +16453,9 @@
                     listener: handleIdentifier(switch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16551,9 +16551,9 @@
                     listener: handleIdentifier(switch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16604,9 +16604,9 @@
                     listener: handleIdentifier(switch, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16740,9 +16740,9 @@
                     listener: handleIdentifier(sync, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16836,9 +16836,9 @@
                     listener: handleIdentifier(sync, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16888,9 +16888,9 @@
                     listener: handleIdentifier(sync, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17027,9 +17027,9 @@
                     listener: handleIdentifier(this, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17125,9 +17125,9 @@
                     listener: handleIdentifier(this, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17178,9 +17178,9 @@
                     listener: handleIdentifier(this, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17317,9 +17317,9 @@
                     listener: handleIdentifier(throw, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17415,9 +17415,9 @@
                     listener: handleIdentifier(throw, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17468,9 +17468,9 @@
                     listener: handleIdentifier(throw, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17607,9 +17607,9 @@
                     listener: handleIdentifier(true, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17705,9 +17705,9 @@
                     listener: handleIdentifier(true, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17758,9 +17758,9 @@
                     listener: handleIdentifier(true, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17897,9 +17897,9 @@
                     listener: handleIdentifier(try, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17995,9 +17995,9 @@
                     listener: handleIdentifier(try, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18048,9 +18048,9 @@
                     listener: handleIdentifier(try, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18184,9 +18184,9 @@
                     listener: handleIdentifier(typedef, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18280,9 +18280,9 @@
                     listener: handleIdentifier(typedef, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18332,9 +18332,9 @@
                     listener: handleIdentifier(typedef, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18471,9 +18471,9 @@
                     listener: handleIdentifier(var, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18569,9 +18569,9 @@
                     listener: handleIdentifier(var, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18622,9 +18622,9 @@
                     listener: handleIdentifier(var, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18761,9 +18761,9 @@
                     listener: handleIdentifier(void, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18859,9 +18859,9 @@
                     listener: handleIdentifier(void, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18912,9 +18912,9 @@
                     listener: handleIdentifier(void, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19051,9 +19051,9 @@
                     listener: handleIdentifier(while, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19149,9 +19149,9 @@
                     listener: handleIdentifier(while, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19202,9 +19202,9 @@
                     listener: handleIdentifier(while, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19341,9 +19341,9 @@
                     listener: handleIdentifier(with, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19439,9 +19439,9 @@
                     listener: handleIdentifier(with, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19492,9 +19492,9 @@
                     listener: handleIdentifier(with, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19628,9 +19628,9 @@
                     listener: handleIdentifier(yield, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19724,9 +19724,9 @@
                     listener: handleIdentifier(yield, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19776,9 +19776,9 @@
                     listener: handleIdentifier(yield, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter_prime.dart.intertwined.expect
index d4fea1c..49fa0ce 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_formal_parameter_prime.dart.intertwined.expect
@@ -115,9 +115,9 @@
                     listener: handleIdentifier(abstractX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -209,9 +209,9 @@
                     listener: handleIdentifier(abstractX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -260,9 +260,9 @@
                     listener: handleIdentifier(abstractX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -393,9 +393,9 @@
                     listener: handleIdentifier(asX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -487,9 +487,9 @@
                     listener: handleIdentifier(asX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -538,9 +538,9 @@
                     listener: handleIdentifier(asX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -671,9 +671,9 @@
                     listener: handleIdentifier(assertX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -765,9 +765,9 @@
                     listener: handleIdentifier(assertX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -816,9 +816,9 @@
                     listener: handleIdentifier(assertX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -949,9 +949,9 @@
                     listener: handleIdentifier(asyncX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1043,9 +1043,9 @@
                     listener: handleIdentifier(asyncX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1094,9 +1094,9 @@
                     listener: handleIdentifier(asyncX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1227,9 +1227,9 @@
                     listener: handleIdentifier(awaitX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1321,9 +1321,9 @@
                     listener: handleIdentifier(awaitX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1372,9 +1372,9 @@
                     listener: handleIdentifier(awaitX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1505,9 +1505,9 @@
                     listener: handleIdentifier(breakX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1599,9 +1599,9 @@
                     listener: handleIdentifier(breakX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1650,9 +1650,9 @@
                     listener: handleIdentifier(breakX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1783,9 +1783,9 @@
                     listener: handleIdentifier(caseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1877,9 +1877,9 @@
                     listener: handleIdentifier(caseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -1928,9 +1928,9 @@
                     listener: handleIdentifier(caseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2061,9 +2061,9 @@
                     listener: handleIdentifier(catchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2155,9 +2155,9 @@
                     listener: handleIdentifier(catchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2206,9 +2206,9 @@
                     listener: handleIdentifier(catchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2339,9 +2339,9 @@
                     listener: handleIdentifier(classX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2433,9 +2433,9 @@
                     listener: handleIdentifier(classX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2484,9 +2484,9 @@
                     listener: handleIdentifier(classX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2617,9 +2617,9 @@
                     listener: handleIdentifier(constX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2711,9 +2711,9 @@
                     listener: handleIdentifier(constX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2762,9 +2762,9 @@
                     listener: handleIdentifier(constX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2895,9 +2895,9 @@
                     listener: handleIdentifier(continueX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -2989,9 +2989,9 @@
                     listener: handleIdentifier(continueX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3040,9 +3040,9 @@
                     listener: handleIdentifier(continueX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3173,9 +3173,9 @@
                     listener: handleIdentifier(covariantX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3267,9 +3267,9 @@
                     listener: handleIdentifier(covariantX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3318,9 +3318,9 @@
                     listener: handleIdentifier(covariantX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3451,9 +3451,9 @@
                     listener: handleIdentifier(defaultX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3545,9 +3545,9 @@
                     listener: handleIdentifier(defaultX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3596,9 +3596,9 @@
                     listener: handleIdentifier(defaultX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3729,9 +3729,9 @@
                     listener: handleIdentifier(deferredX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3823,9 +3823,9 @@
                     listener: handleIdentifier(deferredX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -3874,9 +3874,9 @@
                     listener: handleIdentifier(deferredX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4007,9 +4007,9 @@
                     listener: handleIdentifier(doX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4101,9 +4101,9 @@
                     listener: handleIdentifier(doX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4152,9 +4152,9 @@
                     listener: handleIdentifier(doX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4285,9 +4285,9 @@
                     listener: handleIdentifier(dynamicX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4379,9 +4379,9 @@
                     listener: handleIdentifier(dynamicX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4430,9 +4430,9 @@
                     listener: handleIdentifier(dynamicX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4563,9 +4563,9 @@
                     listener: handleIdentifier(elseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4657,9 +4657,9 @@
                     listener: handleIdentifier(elseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4708,9 +4708,9 @@
                     listener: handleIdentifier(elseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4841,9 +4841,9 @@
                     listener: handleIdentifier(enumX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4935,9 +4935,9 @@
                     listener: handleIdentifier(enumX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -4986,9 +4986,9 @@
                     listener: handleIdentifier(enumX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5119,9 +5119,9 @@
                     listener: handleIdentifier(exportX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5213,9 +5213,9 @@
                     listener: handleIdentifier(exportX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5264,9 +5264,9 @@
                     listener: handleIdentifier(exportX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5397,9 +5397,9 @@
                     listener: handleIdentifier(extendsX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5491,9 +5491,9 @@
                     listener: handleIdentifier(extendsX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5542,9 +5542,9 @@
                     listener: handleIdentifier(extendsX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5675,9 +5675,9 @@
                     listener: handleIdentifier(extensionX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5769,9 +5769,9 @@
                     listener: handleIdentifier(extensionX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5820,9 +5820,9 @@
                     listener: handleIdentifier(extensionX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -5953,9 +5953,9 @@
                     listener: handleIdentifier(externalX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6047,9 +6047,9 @@
                     listener: handleIdentifier(externalX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6098,9 +6098,9 @@
                     listener: handleIdentifier(externalX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6231,9 +6231,9 @@
                     listener: handleIdentifier(factoryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6325,9 +6325,9 @@
                     listener: handleIdentifier(factoryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6376,9 +6376,9 @@
                     listener: handleIdentifier(factoryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6509,9 +6509,9 @@
                     listener: handleIdentifier(falseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6603,9 +6603,9 @@
                     listener: handleIdentifier(falseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6654,9 +6654,9 @@
                     listener: handleIdentifier(falseX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6787,9 +6787,9 @@
                     listener: handleIdentifier(finalX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6881,9 +6881,9 @@
                     listener: handleIdentifier(finalX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -6932,9 +6932,9 @@
                     listener: handleIdentifier(finalX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7065,9 +7065,9 @@
                     listener: handleIdentifier(finallyX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7159,9 +7159,9 @@
                     listener: handleIdentifier(finallyX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7210,9 +7210,9 @@
                     listener: handleIdentifier(finallyX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7343,9 +7343,9 @@
                     listener: handleIdentifier(forX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7437,9 +7437,9 @@
                     listener: handleIdentifier(forX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7488,9 +7488,9 @@
                     listener: handleIdentifier(forX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7621,9 +7621,9 @@
                     listener: handleIdentifier(FunctionX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7715,9 +7715,9 @@
                     listener: handleIdentifier(FunctionX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7766,9 +7766,9 @@
                     listener: handleIdentifier(FunctionX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7899,9 +7899,9 @@
                     listener: handleIdentifier(getX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -7993,9 +7993,9 @@
                     listener: handleIdentifier(getX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8044,9 +8044,9 @@
                     listener: handleIdentifier(getX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8177,9 +8177,9 @@
                     listener: handleIdentifier(hideX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8271,9 +8271,9 @@
                     listener: handleIdentifier(hideX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8322,9 +8322,9 @@
                     listener: handleIdentifier(hideX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8455,9 +8455,9 @@
                     listener: handleIdentifier(ifX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8549,9 +8549,9 @@
                     listener: handleIdentifier(ifX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8600,9 +8600,9 @@
                     listener: handleIdentifier(ifX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8733,9 +8733,9 @@
                     listener: handleIdentifier(implementsX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8827,9 +8827,9 @@
                     listener: handleIdentifier(implementsX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -8878,9 +8878,9 @@
                     listener: handleIdentifier(implementsX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9011,9 +9011,9 @@
                     listener: handleIdentifier(importX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9105,9 +9105,9 @@
                     listener: handleIdentifier(importX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9156,9 +9156,9 @@
                     listener: handleIdentifier(importX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9289,9 +9289,9 @@
                     listener: handleIdentifier(inX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9383,9 +9383,9 @@
                     listener: handleIdentifier(inX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9434,9 +9434,9 @@
                     listener: handleIdentifier(inX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9567,9 +9567,9 @@
                     listener: handleIdentifier(inoutX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9661,9 +9661,9 @@
                     listener: handleIdentifier(inoutX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9712,9 +9712,9 @@
                     listener: handleIdentifier(inoutX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9845,9 +9845,9 @@
                     listener: handleIdentifier(interfaceX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9939,9 +9939,9 @@
                     listener: handleIdentifier(interfaceX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -9990,9 +9990,9 @@
                     listener: handleIdentifier(interfaceX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10123,9 +10123,9 @@
                     listener: handleIdentifier(isX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10217,9 +10217,9 @@
                     listener: handleIdentifier(isX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10268,9 +10268,9 @@
                     listener: handleIdentifier(isX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10401,9 +10401,9 @@
                     listener: handleIdentifier(lateX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10495,9 +10495,9 @@
                     listener: handleIdentifier(lateX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10546,9 +10546,9 @@
                     listener: handleIdentifier(lateX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10679,9 +10679,9 @@
                     listener: handleIdentifier(libraryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10773,9 +10773,9 @@
                     listener: handleIdentifier(libraryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10824,9 +10824,9 @@
                     listener: handleIdentifier(libraryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -10957,9 +10957,9 @@
                     listener: handleIdentifier(mixinX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11051,9 +11051,9 @@
                     listener: handleIdentifier(mixinX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11102,9 +11102,9 @@
                     listener: handleIdentifier(mixinX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11235,9 +11235,9 @@
                     listener: handleIdentifier(nativeX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11329,9 +11329,9 @@
                     listener: handleIdentifier(nativeX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11380,9 +11380,9 @@
                     listener: handleIdentifier(nativeX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11513,9 +11513,9 @@
                     listener: handleIdentifier(newX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11607,9 +11607,9 @@
                     listener: handleIdentifier(newX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11658,9 +11658,9 @@
                     listener: handleIdentifier(newX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11791,9 +11791,9 @@
                     listener: handleIdentifier(nullX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11885,9 +11885,9 @@
                     listener: handleIdentifier(nullX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -11936,9 +11936,9 @@
                     listener: handleIdentifier(nullX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12069,9 +12069,9 @@
                     listener: handleIdentifier(ofX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12163,9 +12163,9 @@
                     listener: handleIdentifier(ofX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12214,9 +12214,9 @@
                     listener: handleIdentifier(ofX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12347,9 +12347,9 @@
                     listener: handleIdentifier(onX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12441,9 +12441,9 @@
                     listener: handleIdentifier(onX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12492,9 +12492,9 @@
                     listener: handleIdentifier(onX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12625,9 +12625,9 @@
                     listener: handleIdentifier(operatorX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12719,9 +12719,9 @@
                     listener: handleIdentifier(operatorX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12770,9 +12770,9 @@
                     listener: handleIdentifier(operatorX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12903,9 +12903,9 @@
                     listener: handleIdentifier(outX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -12997,9 +12997,9 @@
                     listener: handleIdentifier(outX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13048,9 +13048,9 @@
                     listener: handleIdentifier(outX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13181,9 +13181,9 @@
                     listener: handleIdentifier(partX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13275,9 +13275,9 @@
                     listener: handleIdentifier(partX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13326,9 +13326,9 @@
                     listener: handleIdentifier(partX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13459,9 +13459,9 @@
                     listener: handleIdentifier(patchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13553,9 +13553,9 @@
                     listener: handleIdentifier(patchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13604,9 +13604,9 @@
                     listener: handleIdentifier(patchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13737,9 +13737,9 @@
                     listener: handleIdentifier(requiredX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13831,9 +13831,9 @@
                     listener: handleIdentifier(requiredX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -13882,9 +13882,9 @@
                     listener: handleIdentifier(requiredX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14015,9 +14015,9 @@
                     listener: handleIdentifier(rethrowX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14109,9 +14109,9 @@
                     listener: handleIdentifier(rethrowX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14160,9 +14160,9 @@
                     listener: handleIdentifier(rethrowX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14293,9 +14293,9 @@
                     listener: handleIdentifier(returnX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14387,9 +14387,9 @@
                     listener: handleIdentifier(returnX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14438,9 +14438,9 @@
                     listener: handleIdentifier(returnX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14571,9 +14571,9 @@
                     listener: handleIdentifier(setX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14665,9 +14665,9 @@
                     listener: handleIdentifier(setX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14716,9 +14716,9 @@
                     listener: handleIdentifier(setX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14849,9 +14849,9 @@
                     listener: handleIdentifier(showX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14943,9 +14943,9 @@
                     listener: handleIdentifier(showX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -14994,9 +14994,9 @@
                     listener: handleIdentifier(showX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15127,9 +15127,9 @@
                     listener: handleIdentifier(sourceX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15221,9 +15221,9 @@
                     listener: handleIdentifier(sourceX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15272,9 +15272,9 @@
                     listener: handleIdentifier(sourceX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15405,9 +15405,9 @@
                     listener: handleIdentifier(staticX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15499,9 +15499,9 @@
                     listener: handleIdentifier(staticX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15550,9 +15550,9 @@
                     listener: handleIdentifier(staticX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15683,9 +15683,9 @@
                     listener: handleIdentifier(superX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15777,9 +15777,9 @@
                     listener: handleIdentifier(superX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15828,9 +15828,9 @@
                     listener: handleIdentifier(superX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -15961,9 +15961,9 @@
                     listener: handleIdentifier(switchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16055,9 +16055,9 @@
                     listener: handleIdentifier(switchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16106,9 +16106,9 @@
                     listener: handleIdentifier(switchX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16239,9 +16239,9 @@
                     listener: handleIdentifier(syncX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16333,9 +16333,9 @@
                     listener: handleIdentifier(syncX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16384,9 +16384,9 @@
                     listener: handleIdentifier(syncX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16517,9 +16517,9 @@
                     listener: handleIdentifier(thisX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16611,9 +16611,9 @@
                     listener: handleIdentifier(thisX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16662,9 +16662,9 @@
                     listener: handleIdentifier(thisX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16795,9 +16795,9 @@
                     listener: handleIdentifier(throwX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16889,9 +16889,9 @@
                     listener: handleIdentifier(throwX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -16940,9 +16940,9 @@
                     listener: handleIdentifier(throwX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17073,9 +17073,9 @@
                     listener: handleIdentifier(trueX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17167,9 +17167,9 @@
                     listener: handleIdentifier(trueX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17218,9 +17218,9 @@
                     listener: handleIdentifier(trueX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17351,9 +17351,9 @@
                     listener: handleIdentifier(tryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17445,9 +17445,9 @@
                     listener: handleIdentifier(tryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17496,9 +17496,9 @@
                     listener: handleIdentifier(tryX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17629,9 +17629,9 @@
                     listener: handleIdentifier(typedefX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17723,9 +17723,9 @@
                     listener: handleIdentifier(typedefX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17774,9 +17774,9 @@
                     listener: handleIdentifier(typedefX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -17907,9 +17907,9 @@
                     listener: handleIdentifier(varX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18001,9 +18001,9 @@
                     listener: handleIdentifier(varX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18052,9 +18052,9 @@
                     listener: handleIdentifier(varX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18185,9 +18185,9 @@
                     listener: handleIdentifier(voidX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18279,9 +18279,9 @@
                     listener: handleIdentifier(voidX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18330,9 +18330,9 @@
                     listener: handleIdentifier(voidX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18463,9 +18463,9 @@
                     listener: handleIdentifier(whileX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18557,9 +18557,9 @@
                     listener: handleIdentifier(whileX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18608,9 +18608,9 @@
                     listener: handleIdentifier(whileX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18741,9 +18741,9 @@
                     listener: handleIdentifier(withX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18835,9 +18835,9 @@
                     listener: handleIdentifier(withX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -18886,9 +18886,9 @@
                     listener: handleIdentifier(withX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19019,9 +19019,9 @@
                     listener: handleIdentifier(yieldX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19113,9 +19113,9 @@
                     listener: handleIdentifier(yieldX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
                           parseLiteralInt(:)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()
@@ -19164,9 +19164,9 @@
                     listener: handleIdentifier(yieldX, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFormalParameterDefaultValueExpression()

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_fields.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_fields.dart.intertwined.expect
index 8d0fc89..2b6d332 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_fields.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_fields.dart.intertwined.expect
@@ -18,9 +18,9 @@
         parseFieldInitializerOpt(abstract, abstract, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -42,9 +42,9 @@
         parseFieldInitializerOpt(as, as, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -70,9 +70,9 @@
         parseFieldInitializerOpt(assert, assert, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -94,9 +94,9 @@
         parseFieldInitializerOpt(async, async, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -118,9 +118,9 @@
         parseFieldInitializerOpt(await, await, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -146,9 +146,9 @@
         parseFieldInitializerOpt(break, break, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -174,9 +174,9 @@
         parseFieldInitializerOpt(case, case, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -202,9 +202,9 @@
         parseFieldInitializerOpt(catch, catch, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -230,9 +230,9 @@
         parseFieldInitializerOpt(class, class, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -258,9 +258,9 @@
         parseFieldInitializerOpt(const, const, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -286,9 +286,9 @@
         parseFieldInitializerOpt(continue, continue, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -310,9 +310,9 @@
         parseFieldInitializerOpt(covariant, covariant, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -338,9 +338,9 @@
         parseFieldInitializerOpt(default, default, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -362,9 +362,9 @@
         parseFieldInitializerOpt(deferred, deferred, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -390,9 +390,9 @@
         parseFieldInitializerOpt(do, do, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -414,9 +414,9 @@
         parseFieldInitializerOpt(dynamic, dynamic, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -442,9 +442,9 @@
         parseFieldInitializerOpt(else, else, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -470,9 +470,9 @@
         parseFieldInitializerOpt(enum, enum, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -494,9 +494,9 @@
         parseFieldInitializerOpt(export, export, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -522,9 +522,9 @@
         parseFieldInitializerOpt(extends, extends, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -546,9 +546,9 @@
         parseFieldInitializerOpt(extension, extension, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -570,9 +570,9 @@
         parseFieldInitializerOpt(external, external, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -594,9 +594,9 @@
         parseFieldInitializerOpt(factory, factory, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -622,9 +622,9 @@
         parseFieldInitializerOpt(false, false, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -650,9 +650,9 @@
         parseFieldInitializerOpt(final, final, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -678,9 +678,9 @@
         parseFieldInitializerOpt(finally, finally, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -706,9 +706,9 @@
         parseFieldInitializerOpt(for, for, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -730,9 +730,9 @@
         parseFieldInitializerOpt(Function, Function, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -754,9 +754,9 @@
         parseFieldInitializerOpt(get, get, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -778,9 +778,9 @@
         parseFieldInitializerOpt(hide, hide, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -806,9 +806,9 @@
         parseFieldInitializerOpt(if, if, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -830,9 +830,9 @@
         parseFieldInitializerOpt(implements, implements, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -854,9 +854,9 @@
         parseFieldInitializerOpt(import, import, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -882,9 +882,9 @@
         parseFieldInitializerOpt(in, in, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -906,9 +906,9 @@
         parseFieldInitializerOpt(inout, inout, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -930,9 +930,9 @@
         parseFieldInitializerOpt(interface, interface, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -958,9 +958,9 @@
         parseFieldInitializerOpt(is, is, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -982,9 +982,9 @@
         parseFieldInitializerOpt(late, late, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1006,9 +1006,9 @@
         parseFieldInitializerOpt(library, library, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1030,9 +1030,9 @@
         parseFieldInitializerOpt(mixin, mixin, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1054,9 +1054,9 @@
         parseFieldInitializerOpt(native, native, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1082,9 +1082,9 @@
         parseFieldInitializerOpt(new, new, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1110,9 +1110,9 @@
         parseFieldInitializerOpt(null, null, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1134,9 +1134,9 @@
         parseFieldInitializerOpt(of, of, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1158,9 +1158,9 @@
         parseFieldInitializerOpt(on, on, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1182,9 +1182,9 @@
         parseFieldInitializerOpt(operator, operator, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1206,9 +1206,9 @@
         parseFieldInitializerOpt(out, out, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1230,9 +1230,9 @@
         parseFieldInitializerOpt(part, part, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1254,9 +1254,9 @@
         parseFieldInitializerOpt(patch, patch, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1278,9 +1278,9 @@
         parseFieldInitializerOpt(required, required, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1306,9 +1306,9 @@
         parseFieldInitializerOpt(rethrow, rethrow, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1334,9 +1334,9 @@
         parseFieldInitializerOpt(return, return, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1358,9 +1358,9 @@
         parseFieldInitializerOpt(set, set, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1382,9 +1382,9 @@
         parseFieldInitializerOpt(show, show, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1406,9 +1406,9 @@
         parseFieldInitializerOpt(source, source, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1430,9 +1430,9 @@
         parseFieldInitializerOpt(static, static, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1456,9 +1456,9 @@
         parseFieldInitializerOpt(super, super, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1484,9 +1484,9 @@
         parseFieldInitializerOpt(switch, switch, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1508,9 +1508,9 @@
         parseFieldInitializerOpt(sync, sync, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1534,9 +1534,9 @@
         parseFieldInitializerOpt(this, this, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1562,9 +1562,9 @@
         parseFieldInitializerOpt(throw, throw, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1590,9 +1590,9 @@
         parseFieldInitializerOpt(true, true, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1618,9 +1618,9 @@
         parseFieldInitializerOpt(try, try, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1642,9 +1642,9 @@
         parseFieldInitializerOpt(typedef, typedef, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1670,9 +1670,9 @@
         parseFieldInitializerOpt(var, var, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1698,9 +1698,9 @@
         parseFieldInitializerOpt(void, void, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1726,9 +1726,9 @@
         parseFieldInitializerOpt(while, while, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1754,9 +1754,9 @@
         parseFieldInitializerOpt(with, with, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -1778,9 +1778,9 @@
         parseFieldInitializerOpt(yield, yield, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)

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

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 7542220..77362cc 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
@@ -47,9 +47,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -60,9 +60,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -74,9 +74,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -90,9 +90,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -107,9 +107,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -120,18 +120,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(abstract, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -187,9 +187,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -200,9 +200,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -214,9 +214,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -230,9 +230,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -247,9 +247,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -260,18 +260,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(as, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -331,9 +331,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -344,9 +344,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -358,9 +358,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -374,16 +374,16 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseAssert(return, Assert.Expression)
                           listener: beginAssert(assert, Assert.Expression)
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -394,9 +394,9 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
@@ -404,9 +404,9 @@
                             listener: handleRecoverableError(AssertAsExpression, assert, assert)
                           listener: endAssert(assert, Assert.Expression, (, null, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -462,9 +462,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -475,9 +475,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -489,9 +489,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -505,9 +505,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -522,9 +522,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -535,18 +535,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(async, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -602,9 +602,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -615,9 +615,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -629,9 +629,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -645,12 +645,12 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
                       inPlainSync()
                       looksLikeAwaitExpression(return, AwaitOrYieldContext.UnaryExpression)
                         looksLikeExpressionAfterAwaitOrYield(await, AwaitOrYieldContext.UnaryExpression)
-                      parsePrimary(return, expression)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -665,9 +665,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -678,18 +678,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(await, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -749,9 +749,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -762,9 +762,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -776,9 +776,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -792,9 +792,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -833,16 +833,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -853,18 +853,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 ensureCloseParen(1, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -923,9 +923,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -936,9 +936,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -950,9 +950,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -966,9 +966,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -982,9 +982,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -995,18 +995,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(case, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -1066,9 +1066,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1079,9 +1079,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1093,9 +1093,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1109,9 +1109,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -1125,9 +1125,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -1138,18 +1138,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(catch, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -1209,9 +1209,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1222,9 +1222,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1236,9 +1236,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1252,9 +1252,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -1268,9 +1268,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -1281,18 +1281,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(class, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -1352,9 +1352,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1365,9 +1365,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1379,9 +1379,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1395,17 +1395,17 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseConstExpression(return)
                           listener: beginConstLiteral(()
-                          parseParenthesizedExpressionOrRecordLiteral(const, const)
+                          parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1416,9 +1416,9 @@
                                           listener: handleNoArguments(-)
                                         listener: handleSend(x, -)
                                 listener: beginBinaryExpression(-)
-                                parsePrecedenceExpression(-, 14, true)
-                                  parseUnaryExpression(-, true)
-                                    parsePrimary(-, expression)
+                                parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                       parseLiteralInt(-)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(-)
@@ -1428,9 +1428,9 @@
                             listener: endRecordLiteral((, 1, const)
                           listener: endConstLiteral(+)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -1490,9 +1490,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1503,9 +1503,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1517,9 +1517,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1533,9 +1533,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -1574,16 +1574,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -1594,18 +1594,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 ensureCloseParen(1, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -1660,9 +1660,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1673,9 +1673,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1687,9 +1687,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1703,9 +1703,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -1720,9 +1720,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1733,18 +1733,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(covariant, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -1804,9 +1804,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1817,9 +1817,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1831,9 +1831,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1847,9 +1847,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -1863,9 +1863,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -1876,18 +1876,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(default, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -1943,9 +1943,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1956,9 +1956,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1970,9 +1970,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1986,9 +1986,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -2003,9 +2003,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2016,18 +2016,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(deferred, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -2087,9 +2087,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2100,9 +2100,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2114,9 +2114,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2130,9 +2130,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -2164,16 +2164,16 @@
                         looksLikeLocalFunction(()
                         parseExpressionStatement(do)
                           parseExpression(do)
-                            parsePrecedenceExpression(do, 1, true)
-                              parseUnaryExpression(do, true)
-                                parsePrimary(do, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do)
-                                    parseParenthesizedExpressionOrRecordLiteral(do, null)
+                            parsePrecedenceExpression(do, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(do, true, ConstantPatternContext.none)
+                                parsePrimary(do, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(do, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(do, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -2184,18 +2184,18 @@
                                                     listener: handleNoArguments(-)
                                                   listener: handleSend(x, -)
                                           listener: beginBinaryExpression(-)
-                                          parsePrecedenceExpression(-, 14, true)
-                                            parseUnaryExpression(-, true)
-                                              parsePrimary(-, expression)
+                                          parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                              parsePrimary(-, expression, ConstantPatternContext.none)
                                                 parseLiteralInt(-)
                                                   listener: handleLiteralInt(1)
                                           listener: endBinaryExpression(-)
                                       ensureCloseParen(1, ()
                                       listener: endParenthesizedExpression(()
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(+)
@@ -2211,9 +2211,9 @@
                   rewriter()
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSend((, expression)
                               isNextIdentifier(()
                               ensureIdentifier((, expression)
@@ -2281,9 +2281,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2294,9 +2294,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2308,9 +2308,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2324,9 +2324,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -2341,9 +2341,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2354,18 +2354,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(dynamic, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -2425,9 +2425,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2438,9 +2438,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2452,9 +2452,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2468,9 +2468,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -2497,9 +2497,9 @@
                   looksLikeLocalFunction(else)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -2527,16 +2527,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(else)
                     parseExpression(else)
-                      parsePrecedenceExpression(else, 1, true)
-                        parseUnaryExpression(else, true)
-                          parsePrimary(else, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else)
-                              parseParenthesizedExpressionOrRecordLiteral(else, null)
+                      parsePrecedenceExpression(else, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(else, true, ConstantPatternContext.none)
+                          parsePrimary(else, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(else, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(else, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -2547,18 +2547,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 ensureCloseParen(1, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -2617,9 +2617,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2630,9 +2630,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2644,9 +2644,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2660,9 +2660,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -2676,9 +2676,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -2689,18 +2689,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(enum, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -2756,9 +2756,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2769,9 +2769,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2783,9 +2783,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2799,9 +2799,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -2816,9 +2816,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2829,18 +2829,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(export, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -2900,9 +2900,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2913,9 +2913,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2927,9 +2927,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2943,9 +2943,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -2959,9 +2959,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -2972,18 +2972,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(extends, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -3039,9 +3039,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3052,9 +3052,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -3066,9 +3066,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -3082,9 +3082,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -3099,9 +3099,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -3112,18 +3112,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(extension, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -3179,9 +3179,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3192,9 +3192,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -3206,9 +3206,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -3222,9 +3222,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -3239,9 +3239,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -3252,18 +3252,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(external, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -3319,9 +3319,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3332,9 +3332,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -3346,9 +3346,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -3362,9 +3362,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -3379,9 +3379,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -3392,18 +3392,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(factory, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -3463,9 +3463,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3476,9 +3476,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -3490,9 +3490,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -3506,9 +3506,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseLiteralBool(return)
                           listener: handleLiteralBool(false)
                     parseArgumentOrIndexStar(false, Instance of 'NoTypeParamOrArg', false)
@@ -3517,9 +3517,9 @@
                         parseArgumentsRest(()
                           listener: beginArguments(()
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -3530,18 +3530,18 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
                           listener: endArguments(1, (, ))
                       listener: handleSend((, ))
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -3601,9 +3601,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3614,9 +3614,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -3628,9 +3628,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -3644,9 +3644,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -3697,9 +3697,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -3710,9 +3710,9 @@
                                 listener: handleNoArguments(-)
                               listener: handleSend(x, -)
                       listener: beginBinaryExpression(-)
-                      parsePrecedenceExpression(-, 14, true)
-                        parseUnaryExpression(-, true)
-                          parsePrimary(-, expression)
+                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                          parsePrimary(-, expression, ConstantPatternContext.none)
                             parseLiteralInt(-)
                               listener: handleLiteralInt(1)
                       listener: endBinaryExpression(-)
@@ -3729,9 +3729,9 @@
                   looksLikeLocalFunction())
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSend(;, expression)
                               isNextIdentifier(;)
                               ensureIdentifier(;, expression)
@@ -3758,13 +3758,13 @@
                   looksLikeLocalFunction(+)
                   parseExpressionStatement())
                     parseExpression())
-                      parsePrecedenceExpression(), 1, true)
-                        parseUnaryExpression(), true)
+                      parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(), true, ConstantPatternContext.none)
                           rewriteAndRecover(), UnsupportedPrefixPlus, )
                             reportRecoverableError(+, UnsupportedPrefixPlus)
                               listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                             rewriter()
-                          parsePrimary(), expression)
+                          parsePrimary(), expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(), expression)
                               parseSend(), expression)
                                 isNextIdentifier())
@@ -3775,9 +3775,9 @@
                                   listener: handleNoArguments(+)
                                 listener: handleSend(, +)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -3836,9 +3836,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3849,9 +3849,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -3863,9 +3863,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -3879,9 +3879,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -3895,9 +3895,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -3908,18 +3908,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(finally, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -3979,9 +3979,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -3992,9 +3992,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4006,9 +4006,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4022,9 +4022,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -4053,9 +4053,9 @@
                     parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, ForPartsContext(null))
                 parseForLoopPartsMid((, null, for)
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral((, expression)
                             parseSend((, expression)
                               isNextIdentifier(()
@@ -4066,9 +4066,9 @@
                                 listener: handleNoArguments(-)
                               listener: handleSend(x, -)
                       listener: beginBinaryExpression(-)
-                      parsePrecedenceExpression(-, 14, true)
-                        parseUnaryExpression(-, true)
-                          parsePrimary(-, expression)
+                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                          parsePrimary(-, expression, ConstantPatternContext.none)
                             parseLiteralInt(-)
                               listener: handleLiteralInt(1)
                       listener: endBinaryExpression(-)
@@ -4081,9 +4081,9 @@
                       rewriter()
                     parseExpressionStatement(;)
                       parseExpression(;)
-                        parsePrecedenceExpression(;, 1, true)
-                          parseUnaryExpression(;, true)
-                            parsePrimary(;, expression)
+                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                            parsePrimary(;, expression, ConstantPatternContext.none)
                               parseSend(;, expression)
                                 isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
@@ -4109,13 +4109,13 @@
                           looksLikeLocalFunction(+)
                           parseExpressionStatement())
                             parseExpression())
-                              parsePrecedenceExpression(), 1, true)
-                                parseUnaryExpression(), true)
+                              parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(), true, ConstantPatternContext.none)
                                   rewriteAndRecover(), UnsupportedPrefixPlus, )
                                     reportRecoverableError(+, UnsupportedPrefixPlus)
                                       listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                     rewriter()
-                                  parsePrimary(), expression)
+                                  parsePrimary(), expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
                                         isNextIdentifier())
@@ -4126,9 +4126,9 @@
                                           listener: handleNoArguments(+)
                                         listener: handleSend(, +)
                                 listener: beginBinaryExpression(+)
-                                parsePrecedenceExpression(+, 14, true)
-                                  parseUnaryExpression(+, true)
-                                    parsePrimary(+, expression)
+                                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                    parsePrimary(+, expression, ConstantPatternContext.none)
                                       parseLiteralInt(+)
                                         listener: handleLiteralInt(1)
                                 listener: endBinaryExpression(+)
@@ -4185,9 +4185,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4198,9 +4198,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4212,9 +4212,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4228,9 +4228,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -4245,9 +4245,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -4258,18 +4258,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(Function, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -4325,9 +4325,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4338,9 +4338,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4352,9 +4352,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4368,9 +4368,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -4385,9 +4385,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -4398,18 +4398,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(get, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -4465,9 +4465,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4478,9 +4478,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4492,9 +4492,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4508,9 +4508,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -4525,9 +4525,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -4538,18 +4538,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(hide, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -4609,9 +4609,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4622,9 +4622,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4636,9 +4636,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4652,9 +4652,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -4681,9 +4681,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4694,9 +4694,9 @@
                                   listener: handleNoArguments(-)
                                 listener: handleSend(x, -)
                         listener: beginBinaryExpression(-)
-                        parsePrecedenceExpression(-, 14, true)
-                          parseUnaryExpression(-, true)
-                            parsePrimary(-, expression)
+                        parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(-, true, ConstantPatternContext.none)
+                            parsePrimary(-, expression, ConstantPatternContext.none)
                               parseLiteralInt(-)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(-)
@@ -4710,13 +4710,13 @@
                         looksLikeLocalFunction(+)
                         parseExpressionStatement())
                           parseExpression())
-                            parsePrecedenceExpression(), 1, true)
-                              parseUnaryExpression(), true)
+                            parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(), true, ConstantPatternContext.none)
                                 rewriteAndRecover(), UnsupportedPrefixPlus, )
                                   reportRecoverableError(+, UnsupportedPrefixPlus)
                                     listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                   rewriter()
-                                parsePrimary(), expression)
+                                parsePrimary(), expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(), expression)
                                     parseSend(), expression)
                                       isNextIdentifier())
@@ -4727,9 +4727,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(+)
@@ -4786,9 +4786,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4799,9 +4799,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4813,9 +4813,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4829,9 +4829,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -4846,9 +4846,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -4859,18 +4859,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(implements, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -4926,9 +4926,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -4939,9 +4939,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -4953,9 +4953,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -4969,9 +4969,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -4986,9 +4986,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -4999,18 +4999,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(import, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -5070,9 +5070,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5083,9 +5083,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5097,9 +5097,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5113,9 +5113,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -5129,9 +5129,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -5142,18 +5142,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(in, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -5209,9 +5209,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5222,9 +5222,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5236,9 +5236,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5252,9 +5252,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -5269,9 +5269,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -5282,18 +5282,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(inout, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -5349,9 +5349,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5362,9 +5362,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5376,9 +5376,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5392,9 +5392,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -5409,9 +5409,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -5422,18 +5422,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(interface, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -5493,9 +5493,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5506,9 +5506,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5520,9 +5520,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5536,9 +5536,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -5589,13 +5589,13 @@
                   looksLikeLocalFunction(+)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
                           rewriteAndRecover(;, UnsupportedPrefixPlus, )
                             reportRecoverableError(+, UnsupportedPrefixPlus)
                               listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                             rewriter()
-                          parsePrimary(;, expression)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
                                 isNextIdentifier(;)
@@ -5606,9 +5606,9 @@
                                   listener: handleNoArguments(+)
                                 listener: handleSend(, +)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -5663,9 +5663,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5676,9 +5676,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5690,9 +5690,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5706,9 +5706,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -5723,9 +5723,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -5736,18 +5736,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(late, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -5803,9 +5803,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5816,9 +5816,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5830,9 +5830,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5846,9 +5846,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -5863,9 +5863,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -5876,18 +5876,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(library, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -5943,9 +5943,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -5956,9 +5956,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -5970,9 +5970,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -5986,9 +5986,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -6003,9 +6003,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -6016,18 +6016,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(mixin, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6083,9 +6083,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6096,9 +6096,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6110,9 +6110,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6126,9 +6126,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -6143,9 +6143,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -6156,18 +6156,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(native, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6227,9 +6227,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6240,9 +6240,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6254,9 +6254,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6270,9 +6270,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseNewExpression(return)
                           isNextIdentifier(new)
                           listener: beginNewExpression(new)
@@ -6292,9 +6292,9 @@
                             parseArgumentsRest(()
                               listener: beginArguments(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
                                           isNextIdentifier(()
@@ -6305,18 +6305,18 @@
                                             listener: handleNoArguments(-)
                                           listener: handleSend(x, -)
                                   listener: beginBinaryExpression(-)
-                                  parsePrecedenceExpression(-, 14, true)
-                                    parseUnaryExpression(-, true)
-                                      parsePrimary(-, expression)
+                                  parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                      parsePrimary(-, expression, ConstantPatternContext.none)
                                         parseLiteralInt(-)
                                           listener: handleLiteralInt(1)
                                   listener: endBinaryExpression(-)
                               listener: endArguments(1, (, ))
                           listener: endNewExpression(new)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6376,9 +6376,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6389,9 +6389,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6403,9 +6403,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6419,9 +6419,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseLiteralNull(return)
                           listener: handleLiteralNull(null)
                     parseArgumentOrIndexStar(null, Instance of 'NoTypeParamOrArg', false)
@@ -6430,9 +6430,9 @@
                         parseArgumentsRest(()
                           listener: beginArguments(()
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -6443,18 +6443,18 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
                           listener: endArguments(1, (, ))
                       listener: handleSend((, ))
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6510,9 +6510,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6523,9 +6523,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6537,9 +6537,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6553,9 +6553,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -6570,9 +6570,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -6583,18 +6583,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(of, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6650,9 +6650,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6663,9 +6663,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6677,9 +6677,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6693,9 +6693,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -6710,9 +6710,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -6723,18 +6723,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(on, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6790,9 +6790,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6803,9 +6803,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6817,9 +6817,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6833,9 +6833,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -6850,9 +6850,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -6863,18 +6863,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(operator, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -6930,9 +6930,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -6943,9 +6943,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -6957,9 +6957,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -6973,9 +6973,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -6990,9 +6990,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -7003,18 +7003,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(out, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7070,9 +7070,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7083,9 +7083,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7097,9 +7097,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7113,9 +7113,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -7130,9 +7130,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -7143,18 +7143,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(part, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7210,9 +7210,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7223,9 +7223,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7237,9 +7237,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7253,9 +7253,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -7270,9 +7270,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -7283,18 +7283,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(patch, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7350,9 +7350,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7363,9 +7363,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7377,9 +7377,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7393,9 +7393,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -7410,9 +7410,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -7423,18 +7423,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(required, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7494,9 +7494,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7507,9 +7507,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7521,9 +7521,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7537,9 +7537,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -7553,9 +7553,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -7566,18 +7566,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(rethrow, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7637,9 +7637,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7650,9 +7650,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7664,9 +7664,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7680,20 +7680,20 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         reportRecoverableErrorWithToken(return, Instance of 'Template<(Token) => Message>')
                           listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return)
-                        parsePrimary(return, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                            parseParenthesizedExpressionOrRecordLiteral(return, null)
+                        parsePrimary(return, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
                                           isNextIdentifier(()
@@ -7704,18 +7704,18 @@
                                             listener: handleNoArguments(-)
                                           listener: handleSend(x, -)
                                   listener: beginBinaryExpression(-)
-                                  parsePrecedenceExpression(-, 14, true)
-                                    parseUnaryExpression(-, true)
-                                      parsePrimary(-, expression)
+                                  parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                      parsePrimary(-, expression, ConstantPatternContext.none)
                                         parseLiteralInt(-)
                                           listener: handleLiteralInt(1)
                                   listener: endBinaryExpression(-)
                               ensureCloseParen(1, ()
                               listener: endParenthesizedExpression(()
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7771,9 +7771,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7784,9 +7784,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7798,9 +7798,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7814,9 +7814,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -7831,9 +7831,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -7844,18 +7844,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(set, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -7911,9 +7911,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -7924,9 +7924,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -7938,9 +7938,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -7954,9 +7954,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -7971,9 +7971,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -7984,18 +7984,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(show, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -8051,9 +8051,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8064,9 +8064,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8078,9 +8078,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8094,9 +8094,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -8111,9 +8111,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -8124,18 +8124,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(source, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -8191,9 +8191,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8204,9 +8204,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8218,9 +8218,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8234,9 +8234,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -8251,9 +8251,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -8264,18 +8264,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(static, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -8333,9 +8333,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8346,9 +8346,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8360,9 +8360,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8376,9 +8376,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSuperExpression(return, expression)
                           listener: handleSuperExpression(super, expression)
                           listener: handleNoTypeArguments(()
@@ -8386,9 +8386,9 @@
                             parseArgumentsRest(()
                               listener: beginArguments(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
                                           isNextIdentifier(()
@@ -8399,18 +8399,18 @@
                                             listener: handleNoArguments(-)
                                           listener: handleSend(x, -)
                                   listener: beginBinaryExpression(-)
-                                  parsePrecedenceExpression(-, 14, true)
-                                    parseUnaryExpression(-, true)
-                                      parsePrimary(-, expression)
+                                  parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                      parsePrimary(-, expression, ConstantPatternContext.none)
                                         parseLiteralInt(-)
                                           listener: handleLiteralInt(1)
                                   listener: endBinaryExpression(-)
                               listener: endArguments(1, (, ))
                           listener: handleSend(super, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -8470,9 +8470,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8483,9 +8483,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8497,9 +8497,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8513,9 +8513,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -8542,9 +8542,9 @@
                 ensureParenthesizedCondition(switch, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8555,9 +8555,9 @@
                                   listener: handleNoArguments(-)
                                 listener: handleSend(x, -)
                         listener: beginBinaryExpression(-)
-                        parsePrecedenceExpression(-, 14, true)
-                          parseUnaryExpression(-, true)
-                            parsePrimary(-, expression)
+                        parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(-, true, ConstantPatternContext.none)
+                            parsePrimary(-, expression, ConstantPatternContext.none)
                               parseLiteralInt(-)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(-)
@@ -8582,13 +8582,13 @@
                   looksLikeLocalFunction(+)
                   parseExpressionStatement(})
                     parseExpression(})
-                      parsePrecedenceExpression(}, 1, true)
-                        parseUnaryExpression(}, true)
+                      parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(}, true, ConstantPatternContext.none)
                           rewriteAndRecover(}, UnsupportedPrefixPlus, )
                             reportRecoverableError(+, UnsupportedPrefixPlus)
                               listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                             rewriter()
-                          parsePrimary(}, expression)
+                          parsePrimary(}, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(}, expression)
                               parseSend(}, expression)
                                 isNextIdentifier(})
@@ -8599,9 +8599,9 @@
                                   listener: handleNoArguments(+)
                                 listener: handleSend(, +)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -8656,9 +8656,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8669,9 +8669,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8683,9 +8683,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8699,9 +8699,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -8716,9 +8716,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -8729,18 +8729,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(sync, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -8798,9 +8798,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8811,9 +8811,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8825,9 +8825,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8841,9 +8841,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseThisExpression(return, expression)
                           listener: handleThisExpression(this, expression)
                           listener: handleNoTypeArguments(()
@@ -8851,9 +8851,9 @@
                             parseArgumentsRest(()
                               listener: beginArguments(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
                                           isNextIdentifier(()
@@ -8864,18 +8864,18 @@
                                             listener: handleNoArguments(-)
                                           listener: handleSend(x, -)
                                   listener: beginBinaryExpression(-)
-                                  parsePrecedenceExpression(-, 14, true)
-                                    parseUnaryExpression(-, true)
-                                      parsePrimary(-, expression)
+                                  parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                      parsePrimary(-, expression, ConstantPatternContext.none)
                                         parseLiteralInt(-)
                                           listener: handleLiteralInt(1)
                                   listener: endBinaryExpression(-)
                               listener: endArguments(1, (, ))
                           listener: handleSend(this, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -8935,9 +8935,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -8948,9 +8948,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -8962,9 +8962,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -8980,16 +8980,16 @@
                 parseExpression(return)
                   parseThrowExpression(return, true)
                     parseExpression(throw)
-                      parsePrecedenceExpression(throw, 1, true)
-                        parseUnaryExpression(throw, true)
-                          parsePrimary(throw, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw)
-                              parseParenthesizedExpressionOrRecordLiteral(throw, null)
+                      parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                          parsePrimary(throw, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(throw, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(throw, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -9000,18 +9000,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 ensureCloseParen(1, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -9072,9 +9072,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -9085,9 +9085,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -9099,9 +9099,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -9115,9 +9115,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseLiteralBool(return)
                           listener: handleLiteralBool(true)
                     parseArgumentOrIndexStar(true, Instance of 'NoTypeParamOrArg', false)
@@ -9126,9 +9126,9 @@
                         parseArgumentsRest(()
                           listener: beginArguments(()
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -9139,18 +9139,18 @@
                                         listener: handleNoArguments(-)
                                       listener: handleSend(x, -)
                               listener: beginBinaryExpression(-)
-                              parsePrecedenceExpression(-, 14, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseLiteralInt(-)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(-)
                           listener: endArguments(1, (, ))
                       listener: handleSend((, ))
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -9210,9 +9210,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -9223,9 +9223,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -9237,9 +9237,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -9253,9 +9253,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -9300,16 +9300,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(})
                     parseExpression(})
-                      parsePrecedenceExpression(}, 1, true)
-                        parseUnaryExpression(}, true)
-                          parsePrimary(}, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(})
-                              parseParenthesizedExpressionOrRecordLiteral(}, null)
+                      parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(}, true, ConstantPatternContext.none)
+                          parsePrimary(}, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(}, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(}, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -9320,18 +9320,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 ensureCloseParen(1, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -9386,9 +9386,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -9399,9 +9399,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -9413,9 +9413,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -9429,9 +9429,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -9446,9 +9446,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -9459,18 +9459,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(typedef, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -9530,9 +9530,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -9543,9 +9543,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -9557,9 +9557,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -9573,9 +9573,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -9626,9 +9626,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -9639,9 +9639,9 @@
                                 listener: handleNoArguments(-)
                               listener: handleSend(x, -)
                       listener: beginBinaryExpression(-)
-                      parsePrecedenceExpression(-, 14, true)
-                        parseUnaryExpression(-, true)
-                          parsePrimary(-, expression)
+                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                          parsePrimary(-, expression, ConstantPatternContext.none)
                             parseLiteralInt(-)
                               listener: handleLiteralInt(1)
                       listener: endBinaryExpression(-)
@@ -9658,9 +9658,9 @@
                   looksLikeLocalFunction())
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSend(;, expression)
                               isNextIdentifier(;)
                               ensureIdentifier(;, expression)
@@ -9687,13 +9687,13 @@
                   looksLikeLocalFunction(+)
                   parseExpressionStatement())
                     parseExpression())
-                      parsePrecedenceExpression(), 1, true)
-                        parseUnaryExpression(), true)
+                      parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(), true, ConstantPatternContext.none)
                           rewriteAndRecover(), UnsupportedPrefixPlus, )
                             reportRecoverableError(+, UnsupportedPrefixPlus)
                               listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                             rewriter()
-                          parsePrimary(), expression)
+                          parsePrimary(), expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(), expression)
                               parseSend(), expression)
                                 isNextIdentifier())
@@ -9704,9 +9704,9 @@
                                   listener: handleNoArguments(+)
                                 listener: handleSend(, +)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -9765,9 +9765,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -9778,9 +9778,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -9792,9 +9792,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -9808,9 +9808,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
                             isNextIdentifier(return)
@@ -9862,9 +9862,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -9875,9 +9875,9 @@
                                 listener: handleNoArguments(-)
                               listener: handleSend(x, -)
                       listener: beginBinaryExpression(-)
-                      parsePrecedenceExpression(-, 14, true)
-                        parseUnaryExpression(-, true)
-                          parsePrimary(-, expression)
+                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                          parsePrimary(-, expression, ConstantPatternContext.none)
                             parseLiteralInt(-)
                               listener: handleLiteralInt(1)
                       listener: endBinaryExpression(-)
@@ -9894,9 +9894,9 @@
                   looksLikeLocalFunction())
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSend(;, expression)
                               isNextIdentifier(;)
                               ensureIdentifier(;, expression)
@@ -9923,13 +9923,13 @@
                   looksLikeLocalFunction(+)
                   parseExpressionStatement())
                     parseExpression())
-                      parsePrecedenceExpression(), 1, true)
-                        parseUnaryExpression(), true)
+                      parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(), true, ConstantPatternContext.none)
                           rewriteAndRecover(), UnsupportedPrefixPlus, )
                             reportRecoverableError(+, UnsupportedPrefixPlus)
                               listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                             rewriter()
-                          parsePrimary(), expression)
+                          parsePrimary(), expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(), expression)
                               parseSend(), expression)
                                 isNextIdentifier())
@@ -9940,9 +9940,9 @@
                                   listener: handleNoArguments(+)
                                 listener: handleSend(, +)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
                               parseLiteralInt(+)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(+)
@@ -10001,9 +10001,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -10014,9 +10014,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -10028,9 +10028,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -10044,9 +10044,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -10073,9 +10073,9 @@
                 ensureParenthesizedCondition(while, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -10086,9 +10086,9 @@
                                   listener: handleNoArguments(-)
                                 listener: handleSend(x, -)
                         listener: beginBinaryExpression(-)
-                        parsePrecedenceExpression(-, 14, true)
-                          parseUnaryExpression(-, true)
-                            parsePrimary(-, expression)
+                        parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(-, true, ConstantPatternContext.none)
+                            parsePrimary(-, expression, ConstantPatternContext.none)
                               parseLiteralInt(-)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(-)
@@ -10102,13 +10102,13 @@
                         looksLikeLocalFunction(+)
                         parseExpressionStatement())
                           parseExpression())
-                            parsePrecedenceExpression(), 1, true)
-                              parseUnaryExpression(), true)
+                            parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(), true, ConstantPatternContext.none)
                                 rewriteAndRecover(), UnsupportedPrefixPlus, )
                                   reportRecoverableError(+, UnsupportedPrefixPlus)
                                     listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                   rewriter()
-                                parsePrimary(), expression)
+                                parsePrimary(), expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(), expression)
                                     parseSend(), expression)
                                       isNextIdentifier())
@@ -10119,9 +10119,9 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
                                     parseLiteralInt(+)
                                       listener: handleLiteralInt(1)
                               listener: endBinaryExpression(+)
@@ -10182,9 +10182,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -10195,9 +10195,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -10209,9 +10209,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -10225,9 +10225,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSend(return, expression)
                           isNextIdentifier(return)
@@ -10241,9 +10241,9 @@
                               parseArgumentsRest(()
                                 listener: beginArguments(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -10254,18 +10254,18 @@
                                               listener: handleNoArguments(-)
                                             listener: handleSend(x, -)
                                     listener: beginBinaryExpression(-)
-                                    parsePrecedenceExpression(-, 14, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                    parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseLiteralInt(-)
                                             listener: handleLiteralInt(1)
                                     listener: endBinaryExpression(-)
                                 listener: endArguments(1, (, ))
                           listener: handleSend(with, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)
@@ -10321,9 +10321,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -10334,9 +10334,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -10348,9 +10348,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -10364,9 +10364,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
@@ -10381,9 +10381,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -10394,18 +10394,18 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
                                   listener: endArguments(1, (, ))
                             listener: handleSend(yield, +)
                     listener: beginBinaryExpression(+)
-                    parsePrecedenceExpression(+, 14, true)
-                      parseUnaryExpression(+, true)
-                        parsePrimary(+, expression)
+                    parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                      parseUnaryExpression(+, true, ConstantPatternContext.none)
+                        parsePrimary(+, expression, ConstantPatternContext.none)
                           parseLiteralInt(+)
                             listener: handleLiteralInt(1)
                     listener: endBinaryExpression(+)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/method_called_with.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/method_called_with.dart.intertwined.expect
index c1c6a56..800cb9c 100644
--- a/pkg/front_end/parser_testcases/error_recovery/method_called_with.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/method_called_with.dart.intertwined.expect
@@ -59,9 +59,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(7)
                     ensureSemicolon(7)
@@ -89,9 +89,9 @@
                 parseFieldInitializerOpt(with, with, null, null, null, null, null, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(7)
                   listener: endFieldInitializer(=, ;)
@@ -128,9 +128,9 @@
                 parseFunctionBody(with, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(7)
                     ensureSemicolon(7)
@@ -219,9 +219,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(7)
             ensureSemicolon(7)
@@ -249,9 +249,9 @@
         parseFieldInitializerOpt(with, with, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(7)
           listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/method_called_with_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/method_called_with_prime.dart.intertwined.expect
index eac767e..a8134df 100644
--- a/pkg/front_end/parser_testcases/error_recovery/method_called_with_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/method_called_with_prime.dart.intertwined.expect
@@ -55,9 +55,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(7)
                     ensureSemicolon(7)
@@ -81,9 +81,9 @@
                 parseFieldInitializerOpt(With, With, null, null, null, null, null, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(7)
                   listener: endFieldInitializer(=, ;)
@@ -116,9 +116,9 @@
                 parseFunctionBody(With, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(7)
                     ensureSemicolon(7)
@@ -199,9 +199,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(7)
             ensureSemicolon(7)
@@ -225,9 +225,9 @@
         parseFieldInitializerOpt(With, With, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(7)
           listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/symbols.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/symbols.dart.intertwined.expect
index 5223cb1..4a22378 100644
--- a/pkg/front_end/parser_testcases/error_recovery/symbols.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/symbols.dart.intertwined.expect
@@ -34,9 +34,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             parseLiteralSymbol({)
                               listener: beginLiteralSymbol(#)
                               listener: handleSymbolVoid(void)
@@ -51,14 +51,14 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               listener: handleSymbolVoid(void)
                               listener: endLiteralSymbol(#, 1)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -79,9 +79,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -101,9 +101,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -121,9 +121,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -141,9 +141,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -161,9 +161,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -181,9 +181,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -201,9 +201,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -221,9 +221,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -241,9 +241,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -261,9 +261,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -281,9 +281,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -301,9 +301,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -321,9 +321,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -341,9 +341,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -361,9 +361,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -381,9 +381,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -401,9 +401,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -421,9 +421,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -441,9 +441,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -461,9 +461,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -481,9 +481,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -501,9 +501,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -521,9 +521,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -541,9 +541,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -561,9 +561,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -581,9 +581,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -601,9 +601,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -621,9 +621,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -641,9 +641,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -661,9 +661,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -681,9 +681,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -701,9 +701,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -721,9 +721,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -741,9 +741,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -763,9 +763,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -785,9 +785,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -807,9 +807,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -829,9 +829,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -851,9 +851,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -873,9 +873,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -895,9 +895,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -917,9 +917,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -939,9 +939,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -961,9 +961,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -983,9 +983,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1005,9 +1005,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1027,9 +1027,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1049,9 +1049,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1071,9 +1071,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1093,9 +1093,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1115,9 +1115,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1137,9 +1137,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1159,9 +1159,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1181,9 +1181,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1203,9 +1203,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1225,9 +1225,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1247,9 +1247,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1269,9 +1269,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1291,9 +1291,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1313,9 +1313,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1335,9 +1335,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1357,9 +1357,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1379,9 +1379,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1401,9 +1401,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1423,9 +1423,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1445,9 +1445,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1467,9 +1467,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1489,9 +1489,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1511,9 +1511,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1533,9 +1533,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1555,9 +1555,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1577,9 +1577,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1599,9 +1599,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1621,9 +1621,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1643,9 +1643,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1665,9 +1665,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1687,9 +1687,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1709,9 +1709,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1731,9 +1731,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1753,9 +1753,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1775,9 +1775,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1797,9 +1797,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1819,9 +1819,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1841,9 +1841,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1863,9 +1863,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1885,9 +1885,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1907,9 +1907,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1929,9 +1929,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1951,9 +1951,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1973,9 +1973,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -1995,9 +1995,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -2017,9 +2017,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -2039,9 +2039,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -2061,9 +2061,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -2083,9 +2083,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -2105,9 +2105,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)
@@ -2127,9 +2127,9 @@
                   looksLikeLocalFunction(#)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseLiteralSymbol(;)
                               listener: beginLiteralSymbol(#)
                               ensureIdentifier(#, literalSymbol)

pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect
index ac90ea4..fd32dbd 100644
--- a/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect
@@ -2311,9 +2311,9 @@
                 looksLikeLocalFunction(t)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -2326,9 +2326,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("")
@@ -2338,9 +2338,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], H, H)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2355,9 +2355,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], e, e)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2372,9 +2372,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], l, l)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2389,9 +2389,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], l, l)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2406,9 +2406,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], o, o)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2419,9 +2419,9 @@
                                                   listener: handleNoArguments(,)
                                                 listener: handleSend(o, ,)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2436,9 +2436,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], o, o)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2453,9 +2453,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], r, r)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2470,9 +2470,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], l, l)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2487,9 +2487,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], d, d)
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -2505,9 +2505,9 @@
                                         listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], "", "")
                                       rewriter()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("")

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

diff --git a/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
index 61cc64b..1559f8d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
@@ -32,9 +32,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
                         isNextIdentifier(=>)
@@ -44,7 +44,7 @@
                         parseArgumentsOpt(Future)
                           listener: handleNoArguments(.)
                         listener: handleSend(Future, .)
-                parsePrimary(., expressionContinuation)
+                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     looksLikeFunctionBody(;)
                     parseSend(., expressionContinuation)
@@ -57,9 +57,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(7)
                             listener: endArguments(1, (, ))
@@ -107,9 +107,9 @@
               parseYieldStatement({)
                 listener: beginYieldStatement(yield)
                 parseExpression(yield)
-                  parsePrecedenceExpression(yield, 1, true)
-                    parseUnaryExpression(yield, true)
-                      parsePrimary(yield, expression)
+                  parsePrecedenceExpression(yield, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(yield, true, ConstantPatternContext.none)
+                      parsePrimary(yield, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(yield, expression)
                           looksLikeFunctionBody(;)
                           parseSend(yield, expression)

pkg/front_end/parser_testcases/extension_named_type.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/extension_named_type.dart.intertwined.expect b/pkg/front_end/parser_testcases/extension_named_type.dart.intertwined.expect
index 7505c7d..2ef8afc 100644
--- a/pkg/front_end/parser_testcases/extension_named_type.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/extension_named_type.dart.intertwined.expect
@@ -117,9 +117,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(=>, expression)
                       looksLikeFunctionBody(.)
                       parseSend(=>, expression)
@@ -132,9 +132,9 @@
                             parseArgumentsRest(()
                               listener: beginArguments(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseNewExpression(()
                                         isNextIdentifier(new)
                                         listener: beginNewExpression(new)
@@ -153,7 +153,7 @@
                                         listener: endNewExpression(new)
                               listener: endArguments(1, (, ))
                         listener: handleSend(type, .)
-                parsePrimary(., expressionContinuation)
+                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     looksLikeFunctionBody(;)
                     parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect
index bb775bd..928ecfa 100644
--- a/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect
@@ -64,9 +64,9 @@
         parseFieldInitializerOpt(y, y, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -134,9 +134,9 @@
         parseFieldInitializerOpt(z, z, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralBool(=)
                     listener: handleLiteralBool(true)
           listener: endFieldInitializer(=, ;)
@@ -173,9 +173,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -186,9 +186,9 @@
                                   listener: handleNoArguments(!=)
                                 listener: handleSend(x, !=)
                         listener: beginBinaryExpression(!=)
-                        parsePrecedenceExpression(!=, 8, true)
-                          parseUnaryExpression(!=, true)
-                            parsePrimary(!=, expression)
+                        parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                            parsePrimary(!=, expression, ConstantPatternContext.none)
                               parseLiteralNull(!=)
                                 listener: handleLiteralNull(null)
                         listener: endBinaryExpression(!=)

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

diff --git a/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect
index 72f3f28..9e0e6c1 100644
--- a/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -45,9 +45,9 @@
                               parseArgumentsOpt(foo)
                                 listener: handleNoArguments(=)
                               listener: handleSend(foo, =)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)

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

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 edfe027..c8ba072 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
@@ -82,11 +82,11 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 ensureCloseParen((, ()
                                 listener: endRecordLiteral((, 0, null)
@@ -173,9 +173,9 @@
                 looksLikeLocalFunction(local)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -194,9 +194,9 @@
                 looksLikeLocalFunction(augment)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -283,15 +283,15 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(return, null)
                           parseExpression(...)
-                            parsePrecedenceExpression(..., 1, true)
-                              parseUnaryExpression(..., true)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(..., true, ConstantPatternContext.none)
+                                parsePrimary(..., expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(..., expression)
                                     parseSend(..., expression)
                                       isNextIdentifier(...)
@@ -307,15 +307,15 @@
                               listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], super, super)
                             rewriter()
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSuperExpression(,, expression)
                                     listener: handleSuperExpression(super, expression)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(,, expression)
                                     parseSend(,, expression)
                                       isNextIdentifier(,)
@@ -330,16 +330,16 @@
                               listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], super, super)
                             rewriter()
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSuperExpression(,, expression)
                                     listener: handleSuperExpression(super, expression)
                               parseArgumentOrIndexStar(super, Instance of 'NoTypeParamOrArg', false)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(0)
                                 listener: handleIndexedExpression(null, [, ])
@@ -447,21 +447,21 @@
                   looksLikeLocalFunction([)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(;, null)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralInt([)
                                         listener: handleLiteralInt(0)
                               listener: handleLiteralList(1, [, null, ])
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -473,9 +473,9 @@
                                   listener: handleSend(value, [)
                           parseArgumentOrIndexStar(value, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralInt([)
                                       listener: handleLiteralInt(1)
                             listener: handleIndexedExpression(null, [, ])
@@ -503,9 +503,9 @@
                     parseVariableInitializerOpt(super)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -580,11 +580,11 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 ensureCloseParen((, ()
                                 listener: endRecordLiteral((, 0, null)
@@ -644,9 +644,9 @@
                 looksLikeLocalFunction(local)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -665,9 +665,9 @@
                 looksLikeLocalFunction(augment)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -813,11 +813,11 @@
                           looksLikeLocalFunction(()
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                                      parseParenthesizedExpressionOrRecordLiteral(;, null)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         ensureCloseParen((, ()
                                         listener: endRecordLiteral((, 0, null)
@@ -908,9 +908,9 @@
                         looksLikeLocalFunction(local)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -929,9 +929,9 @@
                         looksLikeLocalFunction(augment)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -1026,11 +1026,11 @@
                           looksLikeLocalFunction(++)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrecedenceExpression(++, 16, true)
-                                    parseUnaryExpression(++, true)
-                                      parsePrimary(++, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrecedenceExpression(++, 16, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(++, true, ConstantPatternContext.none)
+                                      parsePrimary(++, expression, ConstantPatternContext.none)
                                         parseSend(++, expression)
                                           isNextIdentifier(++)
                                           ensureIdentifier(++, expression)
@@ -1053,11 +1053,11 @@
                           looksLikeLocalFunction(--)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrecedenceExpression(--, 16, true)
-                                    parseUnaryExpression(--, true)
-                                      parsePrimary(--, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrecedenceExpression(--, 16, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(--, true, ConstantPatternContext.none)
+                                      parsePrimary(--, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(--, expression)
                                           parseSend(--, expression)
                                             isNextIdentifier(--)
@@ -1081,9 +1081,9 @@
                           looksLikeLocalFunction(super)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     parseSuperExpression(;, expression)
                                       listener: handleSuperExpression(super, expression)
                             ensureSemicolon(super)
@@ -1094,11 +1094,11 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrecedenceExpression(-, 16, true)
-                                parseUnaryExpression(-, true)
-                                  parsePrimary(-, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(-, expression)
                                       parseSend(-, expression)
                                         isNextIdentifier(-)
@@ -1123,9 +1123,9 @@
                           looksLikeLocalFunction(super)
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
                                     parseSuperExpression(;, expression)
                                       listener: handleSuperExpression(super, expression)
                             ensureSemicolon(super)
@@ -1217,9 +1217,9 @@
                             parseVariableInitializerOpt(super)
                               listener: beginVariableInitializer(=)
                               parseExpression(=)
-                                parsePrecedenceExpression(=, 1, true)
-                                  parseUnaryExpression(=, true)
-                                    parsePrimary(=, expression)
+                                parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                    parsePrimary(=, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
                                           isNextIdentifier(=)
@@ -1298,11 +1298,11 @@
                           looksLikeLocalFunction(()
                           parseExpressionStatement(;)
                             parseExpression(;)
-                              parsePrecedenceExpression(;, 1, true)
-                                parseUnaryExpression(;, true)
-                                  parsePrimary(;, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                                      parseParenthesizedExpressionOrRecordLiteral(;, null)
+                              parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                  parsePrimary(;, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                         ensureCloseParen((, ()
                                         listener: endRecordLiteral((, 0, null)
@@ -1362,9 +1362,9 @@
                         looksLikeLocalFunction(local)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)
@@ -1383,9 +1383,9 @@
                         looksLikeLocalFunction(augment)
                         parseExpressionStatement(;)
                           parseExpression(;)
-                            parsePrecedenceExpression(;, 1, true)
-                              parseUnaryExpression(;, true)
-                                parsePrimary(;, expression)
+                            parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                parsePrimary(;, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
                                       isNextIdentifier(;)

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

diff --git a/pkg/front_end/parser_testcases/general/built_in_identifier_class_fields.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/built_in_identifier_class_fields.dart.intertwined.expect
index 0cd92c1..81d49e4 100644
--- a/pkg/front_end/parser_testcases/general/built_in_identifier_class_fields.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/built_in_identifier_class_fields.dart.intertwined.expect
@@ -41,9 +41,9 @@
                 parseFieldInitializerOpt(abstract, abstract, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -65,9 +65,9 @@
                 parseFieldInitializerOpt(as, as, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -89,9 +89,9 @@
                 parseFieldInitializerOpt(covariant, covariant, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -113,9 +113,9 @@
                 parseFieldInitializerOpt(deferred, deferred, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -137,9 +137,9 @@
                 parseFieldInitializerOpt(dynamic, dynamic, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -161,9 +161,9 @@
                 parseFieldInitializerOpt(export, export, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -185,9 +185,9 @@
                 parseFieldInitializerOpt(external, external, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -209,9 +209,9 @@
                 parseFieldInitializerOpt(factory, factory, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -233,9 +233,9 @@
                 parseFieldInitializerOpt(Function, Function, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -258,9 +258,9 @@
                 parseFieldInitializerOpt(get, get, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -282,9 +282,9 @@
                 parseFieldInitializerOpt(implements, implements, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -306,9 +306,9 @@
                 parseFieldInitializerOpt(import, import, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -330,9 +330,9 @@
                 parseFieldInitializerOpt(interface, interface, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -354,9 +354,9 @@
                 parseFieldInitializerOpt(library, library, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -379,9 +379,9 @@
                 parseFieldInitializerOpt(operator, operator, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -403,9 +403,9 @@
                 parseFieldInitializerOpt(mixin, mixin, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -427,9 +427,9 @@
                 parseFieldInitializerOpt(part, part, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -452,9 +452,9 @@
                 parseFieldInitializerOpt(set, set, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -476,9 +476,9 @@
                 parseFieldInitializerOpt(static, static, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)
@@ -500,9 +500,9 @@
                 parseFieldInitializerOpt(typedef, typedef, null, null, null, null, null, DeclarationKind.Class, WrapperClass)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect
index 43acbfc..cf6f642 100644
--- a/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect
@@ -74,9 +74,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -87,9 +87,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -101,9 +101,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -117,9 +117,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -134,9 +134,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -147,9 +147,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -211,9 +211,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -224,9 +224,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -238,9 +238,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -254,9 +254,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -271,9 +271,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -284,9 +284,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -348,9 +348,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -361,9 +361,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -375,9 +375,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -391,9 +391,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -408,9 +408,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -421,9 +421,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -485,9 +485,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -498,9 +498,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -512,9 +512,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -528,9 +528,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -545,9 +545,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -558,9 +558,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -622,9 +622,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -635,9 +635,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -649,9 +649,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -665,9 +665,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -682,9 +682,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -695,9 +695,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -759,9 +759,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -772,9 +772,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -786,9 +786,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -802,9 +802,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -819,9 +819,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -832,9 +832,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -896,9 +896,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -909,9 +909,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -923,9 +923,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -939,9 +939,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -956,9 +956,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -969,9 +969,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1033,9 +1033,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1046,9 +1046,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1060,9 +1060,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1076,9 +1076,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1093,9 +1093,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1106,9 +1106,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1170,9 +1170,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1183,9 +1183,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1197,9 +1197,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1213,9 +1213,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1230,9 +1230,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1243,9 +1243,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1308,9 +1308,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1321,9 +1321,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1335,9 +1335,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1351,9 +1351,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1368,9 +1368,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1381,9 +1381,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1445,9 +1445,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1458,9 +1458,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1472,9 +1472,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1488,9 +1488,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1505,9 +1505,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1518,9 +1518,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1582,9 +1582,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1595,9 +1595,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1609,9 +1609,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1625,9 +1625,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1642,9 +1642,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1655,9 +1655,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1719,9 +1719,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1732,9 +1732,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1746,9 +1746,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1762,9 +1762,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1779,9 +1779,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1792,9 +1792,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1856,9 +1856,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1869,9 +1869,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -1883,9 +1883,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -1899,9 +1899,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -1916,9 +1916,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -1929,9 +1929,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -1995,9 +1995,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2008,9 +2008,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2022,9 +2022,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2038,9 +2038,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -2055,9 +2055,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2068,9 +2068,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -2132,9 +2132,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2145,9 +2145,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2159,9 +2159,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2175,9 +2175,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -2192,9 +2192,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2205,9 +2205,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -2269,9 +2269,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2282,9 +2282,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2296,9 +2296,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2312,9 +2312,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -2329,9 +2329,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2342,9 +2342,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -2407,9 +2407,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2420,9 +2420,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2434,9 +2434,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2450,9 +2450,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -2467,9 +2467,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2480,9 +2480,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -2544,9 +2544,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2557,9 +2557,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2571,9 +2571,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2587,9 +2587,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -2604,9 +2604,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2617,9 +2617,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)
@@ -2681,9 +2681,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2694,9 +2694,9 @@
                                           listener: handleNoArguments(==)
                                         listener: handleSend(x, ==)
                                 listener: beginBinaryExpression(==)
-                                parsePrecedenceExpression(==, 8, true)
-                                  parseUnaryExpression(==, true)
-                                    parsePrimary(==, expression)
+                                parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, true, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
                                       parseLiteralInt(==)
                                         listener: handleLiteralInt(0)
                                 listener: endBinaryExpression(==)
@@ -2708,9 +2708,9 @@
                             parseReturnStatement())
                               listener: beginReturnStatement(return)
                               parseExpression(return)
-                                parsePrecedenceExpression(return, 1, true)
-                                  parseUnaryExpression(return, true)
-                                    parsePrimary(return, expression)
+                                parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(return, true, ConstantPatternContext.none)
+                                    parsePrimary(return, expression, ConstantPatternContext.none)
                                       parseLiteralInt(return)
                                         listener: handleLiteralInt(42)
                               ensureSemicolon(42)
@@ -2724,9 +2724,9 @@
                       parseReturnStatement(;)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
@@ -2741,9 +2741,9 @@
                                         parseArgumentsRest(()
                                           listener: beginArguments(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
                                                       isNextIdentifier(()
@@ -2754,9 +2754,9 @@
                                                         listener: handleNoArguments(-)
                                                       listener: handleSend(x, -)
                                               listener: beginBinaryExpression(-)
-                                              parsePrecedenceExpression(-, 14, true)
-                                                parseUnaryExpression(-, true)
-                                                  parsePrimary(-, expression)
+                                              parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(-)
                                                       listener: handleLiteralInt(1)
                                               listener: endBinaryExpression(-)

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

diff --git a/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_fields.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_fields.dart.intertwined.expect
index 65cde96..5c87fd8 100644
--- a/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_fields.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_fields.dart.intertwined.expect
@@ -18,9 +18,9 @@
         parseFieldInitializerOpt(abstract, abstract, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -42,9 +42,9 @@
         parseFieldInitializerOpt(as, as, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -66,9 +66,9 @@
         parseFieldInitializerOpt(covariant, covariant, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -90,9 +90,9 @@
         parseFieldInitializerOpt(deferred, deferred, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -114,9 +114,9 @@
         parseFieldInitializerOpt(dynamic, dynamic, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -138,9 +138,9 @@
         parseFieldInitializerOpt(export, export, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -162,9 +162,9 @@
         parseFieldInitializerOpt(external, external, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -186,9 +186,9 @@
         parseFieldInitializerOpt(factory, factory, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -210,9 +210,9 @@
         parseFieldInitializerOpt(Function, Function, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -234,9 +234,9 @@
         parseFieldInitializerOpt(get, get, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -258,9 +258,9 @@
         parseFieldInitializerOpt(implements, implements, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -282,9 +282,9 @@
         parseFieldInitializerOpt(import, import, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -306,9 +306,9 @@
         parseFieldInitializerOpt(interface, interface, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -330,9 +330,9 @@
         parseFieldInitializerOpt(library, library, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -354,9 +354,9 @@
         parseFieldInitializerOpt(operator, operator, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -378,9 +378,9 @@
         parseFieldInitializerOpt(mixin, mixin, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -402,9 +402,9 @@
         parseFieldInitializerOpt(part, part, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -426,9 +426,9 @@
         parseFieldInitializerOpt(set, set, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -450,9 +450,9 @@
         parseFieldInitializerOpt(static, static, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)
@@ -474,9 +474,9 @@
         parseFieldInitializerOpt(typedef, typedef, null, null, null, null, null, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseLiteralInt(=)
                     listener: handleLiteralInt(42)
           listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect
index f5cec87..e37816b 100644
--- a/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect
@@ -47,9 +47,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -60,9 +60,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -74,9 +74,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -90,9 +90,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -107,9 +107,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -120,9 +120,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -180,9 +180,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -193,9 +193,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -207,9 +207,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -223,9 +223,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -240,9 +240,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -253,9 +253,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -313,9 +313,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -326,9 +326,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -340,9 +340,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -356,9 +356,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -373,9 +373,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -386,9 +386,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -446,9 +446,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -459,9 +459,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -473,9 +473,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -489,9 +489,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -506,9 +506,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -519,9 +519,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -579,9 +579,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -592,9 +592,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -606,9 +606,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -622,9 +622,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -639,9 +639,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -652,9 +652,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -712,9 +712,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -725,9 +725,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -739,9 +739,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -755,9 +755,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -772,9 +772,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -785,9 +785,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -845,9 +845,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -858,9 +858,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -872,9 +872,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -888,9 +888,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -905,9 +905,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -918,9 +918,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -978,9 +978,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -991,9 +991,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1005,9 +1005,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1021,9 +1021,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1038,9 +1038,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1051,9 +1051,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1111,9 +1111,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1124,9 +1124,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1138,9 +1138,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1154,9 +1154,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1171,9 +1171,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1184,9 +1184,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1244,9 +1244,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1257,9 +1257,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1271,9 +1271,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1287,9 +1287,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1304,9 +1304,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1317,9 +1317,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1377,9 +1377,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1390,9 +1390,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1404,9 +1404,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1420,9 +1420,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1437,9 +1437,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1450,9 +1450,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1510,9 +1510,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1523,9 +1523,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1537,9 +1537,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1553,9 +1553,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1570,9 +1570,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1583,9 +1583,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1643,9 +1643,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1656,9 +1656,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1670,9 +1670,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1686,9 +1686,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1703,9 +1703,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1716,9 +1716,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1776,9 +1776,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1789,9 +1789,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1803,9 +1803,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1819,9 +1819,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1836,9 +1836,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1849,9 +1849,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -1909,9 +1909,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -1922,9 +1922,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -1936,9 +1936,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -1952,9 +1952,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -1969,9 +1969,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -1982,9 +1982,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -2042,9 +2042,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2055,9 +2055,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2069,9 +2069,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2085,9 +2085,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -2102,9 +2102,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2115,9 +2115,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -2175,9 +2175,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2188,9 +2188,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2202,9 +2202,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2218,9 +2218,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -2235,9 +2235,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2248,9 +2248,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -2308,9 +2308,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2321,9 +2321,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2335,9 +2335,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2351,9 +2351,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -2368,9 +2368,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2381,9 +2381,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -2441,9 +2441,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2454,9 +2454,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2468,9 +2468,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2484,9 +2484,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -2501,9 +2501,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2514,9 +2514,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)
@@ -2574,9 +2574,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -2587,9 +2587,9 @@
                                   listener: handleNoArguments(==)
                                 listener: handleSend(x, ==)
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(0)
                         listener: endBinaryExpression(==)
@@ -2601,9 +2601,9 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralInt(return)
                                 listener: handleLiteralInt(42)
                       ensureSemicolon(42)
@@ -2617,9 +2617,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         inPlainSync()
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
@@ -2634,9 +2634,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -2647,9 +2647,9 @@
                                                 listener: handleNoArguments(-)
                                               listener: handleSend(x, -)
                                       listener: beginBinaryExpression(-)
-                                      parsePrecedenceExpression(-, 14, true)
-                                        parseUnaryExpression(-, true)
-                                          parsePrimary(-, expression)
+                                      parsePrecedenceExpression(-, 14, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                          parsePrimary(-, expression, ConstantPatternContext.none)
                                             parseLiteralInt(-)
                                               listener: handleLiteralInt(1)
                                       listener: endBinaryExpression(-)

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block2_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block2_prime.dart.intertwined.expect
index e294ba2..da5c122 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block2_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block2_prime.dart.intertwined.expect
@@ -136,9 +136,9 @@
                 looksLikeLocalFunction(onX)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             looksLikeFunctionBody(;)
                             parseSend(}, expression)
@@ -151,9 +151,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("")

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block3.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block3.dart.intertwined.expect
index 8805aaa..470fa05 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block3.dart.intertwined.expect
@@ -130,11 +130,11 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(})
                     parseExpression(})
-                      parsePrecedenceExpression(}, 1, true)
-                        parseUnaryExpression(}, true)
-                          parsePrimary(}, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(})
-                              parseParenthesizedExpressionOrRecordLiteral(}, null)
+                      parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(}, true, ConstantPatternContext.none)
+                          parsePrimary(}, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(}, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(}, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 ensureCloseParen((, ()
                                 listener: endRecordLiteral((, 0, null)

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block3_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block3_prime.dart.intertwined.expect
index 9ef1f00..4c51bb3 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block3_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block3_prime.dart.intertwined.expect
@@ -103,9 +103,9 @@
                 looksLikeLocalFunction(onX)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             parseSend(}, expression)
                               isNextIdentifier(})
@@ -115,7 +115,7 @@
                               parseArgumentsOpt(onX)
                                 listener: handleNoArguments(.)
                               listener: handleSend(onX, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block4.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block4.dart.intertwined.expect
index dd0aa81..3d55658 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block4.dart.intertwined.expect
@@ -124,9 +124,9 @@
                   looksLikeLocalFunction(=)
                   parseExpressionStatement(})
                     parseExpression(})
-                      parsePrecedenceExpression(}, 1, true)
-                        parseUnaryExpression(}, true)
-                          parsePrimary(}, expression)
+                      parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(}, true, ConstantPatternContext.none)
+                          parsePrimary(}, expression, ConstantPatternContext.none)
                             parseSend(}, expression)
                               isNextIdentifier(})
                               ensureIdentifier(}, expression)
@@ -138,9 +138,9 @@
                               parseArgumentsOpt()
                                 listener: handleNoArguments(=)
                               listener: handleSend(, =)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralInt(=)
                                 listener: handleLiteralInt(42)
                         listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block4_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block4_prime.dart.intertwined.expect
index fc2c38f..cda60d8 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block4_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block4_prime.dart.intertwined.expect
@@ -103,9 +103,9 @@
                 looksLikeLocalFunction(onX)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             parseSend(}, expression)
                               isNextIdentifier(})
@@ -115,9 +115,9 @@
                               parseArgumentsOpt(onX)
                                 listener: handleNoArguments(=)
                               listener: handleSend(onX, =)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block5_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block5_prime.dart.intertwined.expect
index 52a2ffb..58c2b4b 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block5_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block5_prime.dart.intertwined.expect
@@ -103,9 +103,9 @@
                 looksLikeLocalFunction(onX)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             parseSend(}, expression)
                               isNextIdentifier(})

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

diff --git a/pkg/front_end/parser_testcases/general/call_on_after_try_block_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/call_on_after_try_block_prime.dart.intertwined.expect
index 6432eec..5003c71 100644
--- a/pkg/front_end/parser_testcases/general/call_on_after_try_block_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/call_on_after_try_block_prime.dart.intertwined.expect
@@ -91,9 +91,9 @@
                 looksLikeLocalFunction(onX)
                 parseExpressionStatement(})
                   parseExpression(})
-                    parsePrecedenceExpression(}, 1, true)
-                      parseUnaryExpression(}, true)
-                        parsePrimary(}, expression)
+                    parsePrecedenceExpression(}, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(}, true, ConstantPatternContext.none)
+                        parsePrimary(}, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(}, expression)
                             looksLikeFunctionBody(;)
                             parseSend(}, expression)
@@ -106,9 +106,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     listener: endArguments(1, (, ))

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

diff --git a/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect
index ab09879..c7ff710 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(()
                             parseSend({, expression)

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

diff --git a/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect
index b701a34..039038e 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(<)
                             parseSend({, expression)

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

diff --git a/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect
index 29a09de..ec74221 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -56,7 +56,7 @@
                               parseArgumentsOpt(e)
                                 listener: handleNoArguments(.)
                               listener: handleSend(e, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(()
                           parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect
index a3d0c08..91c2697 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -56,7 +56,7 @@
                               parseArgumentsOpt(e)
                                 listener: handleNoArguments(.)
                               listener: handleSend(e, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(<)
                           parseSend(., expressionContinuation)

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

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 f7753b8..d340923 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
@@ -45,16 +45,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           looksLikeFunctionBody())
                                           parseSend((, expression)

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

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 f3d1fd6..c89ac46 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
@@ -45,16 +45,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -64,7 +64,7 @@
                                             parseArgumentsOpt(e)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(e, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         looksLikeFunctionBody())
                                         parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect
index 526bd00..4ac0c11 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -56,7 +56,7 @@
                               parseArgumentsOpt(e)
                                 listener: handleNoArguments(.)
                               listener: handleSend(e, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(<)
                           parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect
index 007c484..6b5dabe 100644
--- a/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       parseVariableInitializerOpt(i)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(0)
                         listener: endVariableInitializer(=)
@@ -63,9 +63,9 @@
                     ensureSemicolon(0)
                     parseExpressionStatement(;)
                       parseExpression(;)
-                        parsePrecedenceExpression(;, 1, true)
-                          parseUnaryExpression(;, true)
-                            parsePrimary(;, expression)
+                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                            parsePrimary(;, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(;, expression)
                                 parseSend(;, expression)
                                   isNextIdentifier(;)
@@ -76,18 +76,18 @@
                                     listener: handleNoArguments(<)
                                   listener: handleSend(i, <)
                           listener: beginBinaryExpression(<)
-                          parsePrecedenceExpression(<, 9, true)
-                            parseUnaryExpression(<, true)
-                              parsePrimary(<, expression)
+                          parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                            parseUnaryExpression(<, true, ConstantPatternContext.none)
+                              parsePrimary(<, expression, ConstantPatternContext.none)
                                 parseLiteralInt(<)
                                   listener: handleLiteralInt(10)
                           listener: endBinaryExpression(<)
                       ensureSemicolon(10)
                       listener: handleExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
                                 isNextIdentifier(;)

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

diff --git a/pkg/front_end/parser_testcases/general/for_in.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for_in.dart.intertwined.expect
index 1b44bc1..e0d3d53 100644
--- a/pkg/front_end/parser_testcases/general/for_in.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for_in.dart.intertwined.expect
@@ -53,9 +53,9 @@
                   parseForInLoopPartsRest(i, null, for, null, i)
                     listener: beginForInExpression([])
                     parseExpression(in)
-                      parsePrecedenceExpression(in, 1, true)
-                        parseUnaryExpression(in, true)
-                          parsePrimary(in, expression)
+                      parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(in, true, ConstantPatternContext.none)
+                          parsePrimary(in, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([])
                             parseLiteralListSuffix(in, null)
                               rewriteSquareBrackets(in)

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

diff --git a/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect
index 02b1b33..62acf06 100644
--- a/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect
@@ -55,9 +55,9 @@
                     parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, ForPartsContext(null))
                 parseForLoopPartsMid((, null, for)
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral((, expression)
                             parseSend((, expression)
                               isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parseForInLoopPartsRest(i, null, for, null, i)
                     listener: beginForInExpression([])
                     parseExpression(in)
-                      parsePrecedenceExpression(in, 1, true)
-                        parseUnaryExpression(in, true)
-                          parsePrimary(in, expression)
+                      parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(in, true, ConstantPatternContext.none)
+                          parsePrimary(in, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([])
                             parseLiteralListSuffix(in, null)
                               rewriteSquareBrackets(in)

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

diff --git a/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect
index 8263197..41ea9a0 100644
--- a/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect
@@ -57,9 +57,9 @@
                     parseExpressionStatementOrDeclarationAfterModifiers((, (, null, null, null, ForPartsContext(null))
                 parseForLoopPartsMid((, null, for)
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral((, expression)
                             parseSend((, expression)
                               isNextIdentifier(()
@@ -69,9 +69,9 @@
                               parseArgumentsOpt(i)
                                 listener: handleNoArguments(=)
                               listener: handleSend(i, =)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(0)
                       listener: handleAssignmentExpression(=)
@@ -81,9 +81,9 @@
                     ensureSemicolon(0)
                     parseExpressionStatement(;)
                       parseExpression(;)
-                        parsePrecedenceExpression(;, 1, true)
-                          parseUnaryExpression(;, true)
-                            parsePrimary(;, expression)
+                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                            parsePrimary(;, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(;, expression)
                                 parseSend(;, expression)
                                   isNextIdentifier(;)
@@ -94,18 +94,18 @@
                                     listener: handleNoArguments(<)
                                   listener: handleSend(i, <)
                           listener: beginBinaryExpression(<)
-                          parsePrecedenceExpression(<, 9, true)
-                            parseUnaryExpression(<, true)
-                              parsePrimary(<, expression)
+                          parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                            parseUnaryExpression(<, true, ConstantPatternContext.none)
+                              parsePrimary(<, expression, ConstantPatternContext.none)
                                 parseLiteralInt(<)
                                   listener: handleLiteralInt(10)
                           listener: endBinaryExpression(<)
                       ensureSemicolon(10)
                       listener: handleExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
                                 isNextIdentifier(;)

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

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 5b4e3bf..87780d5 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
@@ -34,10 +34,10 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression({)
                                 listener: beginFunctionExpression(()

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

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 850bba7..4a9015f 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
@@ -16,15 +16,15 @@
         parseFieldInitializerOpt(typeArgs_closeBrace, typeArgs_closeBrace, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   listener: handleNoTypeArguments({)
                   parseLiteralSetOrMapSuffix(=, null)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral({, expression)
                               parseSend({, expression)
                                 isNextIdentifier({)
@@ -61,15 +61,15 @@
         parseFieldInitializerOpt(typeArgs_closeBracket, typeArgs_closeBracket, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   listener: handleNoTypeArguments([)
                   parseLiteralListSuffix(=, null)
                     parseExpression([)
-                      parsePrecedenceExpression([, 1, true)
-                        parseUnaryExpression([, true)
-                          parsePrimary([, expression)
+                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                          parsePrimary([, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral([, expression)
                               parseSend([, expression)
                                 isNextIdentifier([)
@@ -106,9 +106,9 @@
         parseFieldInitializerOpt(typeArgs_closeParen, typeArgs_closeParen, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -121,9 +121,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -161,15 +161,15 @@
         parseFieldInitializerOpt(typeArgs_colon, typeArgs_colon, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   listener: handleNoTypeArguments({)
                   parseLiteralSetOrMapSuffix(=, null)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral({, expression)
                               parseSend({, expression)
                                 isNextIdentifier({)
@@ -189,9 +189,9 @@
                         listener: endTypeArguments(2, <, >)
                         listener: handleTypeArgumentApplication(<)
                     parseExpression(:)
-                      parsePrecedenceExpression(:, 1, true)
-                        parseUnaryExpression(:, true)
-                          parsePrimary(:, expression)
+                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                          parsePrimary(:, expression, ConstantPatternContext.none)
                             parseLiteralNull(:)
                               listener: handleLiteralNull(null)
                     listener: handleLiteralMapEntry(:, })
@@ -213,15 +213,15 @@
         parseFieldInitializerOpt(typeArgs_comma, typeArgs_comma, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   listener: handleNoTypeArguments([)
                   parseLiteralListSuffix(=, null)
                     parseExpression([)
-                      parsePrecedenceExpression([, 1, true)
-                        parseUnaryExpression([, true)
-                          parsePrimary([, expression)
+                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                          parsePrimary([, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral([, expression)
                               parseSend([, expression)
                                 isNextIdentifier([)
@@ -241,9 +241,9 @@
                         listener: endTypeArguments(2, <, >)
                         listener: handleTypeArgumentApplication(<)
                     parseExpression(,)
-                      parsePrecedenceExpression(,, 1, true)
-                        parseUnaryExpression(,, true)
-                          parsePrimary(,, expression)
+                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                          parsePrimary(,, expression, ConstantPatternContext.none)
                             parseLiteralNull(,)
                               listener: handleLiteralNull(null)
                     listener: handleLiteralList(2, [, null, ])
@@ -264,9 +264,9 @@
         parseFieldInitializerOpt(typeArgs_equals, typeArgs_equals, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -286,9 +286,9 @@
               listener: endTypeArguments(2, <, >)
               listener: handleTypeArgumentApplication(<)
               listener: beginBinaryExpression(==)
-              parsePrecedenceExpression(==, 8, true)
-                parseUnaryExpression(==, true)
-                  parsePrimary(==, expression)
+              parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                parseUnaryExpression(==, true, ConstantPatternContext.none)
+                  parsePrimary(==, expression, ConstantPatternContext.none)
                     parseLiteralNull(==)
                       listener: handleLiteralNull(null)
               listener: endBinaryExpression(==)
@@ -309,9 +309,9 @@
         parseFieldInitializerOpt(typeArgs_not_equals, typeArgs_not_equals, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -331,9 +331,9 @@
               listener: endTypeArguments(2, <, >)
               listener: handleTypeArgumentApplication(<)
               listener: beginBinaryExpression(!=)
-              parsePrecedenceExpression(!=, 8, true)
-                parseUnaryExpression(!=, true)
-                  parsePrimary(!=, expression)
+              parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                  parsePrimary(!=, expression, ConstantPatternContext.none)
                     parseLiteralNull(!=)
                       listener: handleLiteralNull(null)
               listener: endBinaryExpression(!=)
@@ -354,9 +354,9 @@
         parseFieldInitializerOpt(typeArgs_openParen, typeArgs_openParen, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -394,8 +394,8 @@
         parseFieldInitializerOpt(typeArgs_period_methodInvocation, typeArgs_period_methodInvocation, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
                 parseImplicitCreationExpression(=, <, Instance of 'ComplexTypeParamOrArgInfo')
                   listener: beginImplicitCreationExpression(f)
                   parseConstructorReference(=, ConstructorReferenceContext.Implicit, Instance of 'ComplexTypeParamOrArgInfo')
@@ -436,9 +436,9 @@
         parseFieldInitializerOpt(typeArgs_period_methodInvocation_generic, typeArgs_period_methodInvocation_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -457,7 +457,7 @@
               listener: handleType(b, null)
               listener: endTypeArguments(2, <, >)
               listener: handleTypeArgumentApplication(<)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   looksLikeFunctionBody(;)
                   parseSend(., expressionContinuation)
@@ -493,9 +493,9 @@
         parseFieldInitializerOpt(typeArgs_period_propertyAccess, typeArgs_period_propertyAccess, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -514,7 +514,7 @@
               listener: handleType(b, null)
               listener: endTypeArguments(2, <, >)
               listener: handleTypeArgumentApplication(<)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -542,9 +542,9 @@
         parseFieldInitializerOpt(typeArgs_semicolon, typeArgs_semicolon, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -580,9 +580,9 @@
         parseFieldInitializerOpt(operators_ampersand, operators_ampersand, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -595,9 +595,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -608,9 +608,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -622,9 +622,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -635,9 +635,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -650,9 +650,9 @@
                                           listener: handleNoArguments(&)
                                         listener: handleSend(, &)
                                   listener: beginBinaryExpression(&)
-                                  parsePrecedenceExpression(&, 12, true)
-                                    parseUnaryExpression(&, true)
-                                      parsePrimary(&, expression)
+                                  parsePrecedenceExpression(&, 12, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(&, true, ConstantPatternContext.none)
+                                      parsePrimary(&, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
                                             isNextIdentifier(&)
@@ -683,9 +683,9 @@
         parseFieldInitializerOpt(operators_as, operators_as, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -698,9 +698,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -711,9 +711,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -725,9 +725,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -738,9 +738,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       inPlainSync()
                                       parseSendOrFunctionLiteral(>, expression)
                                         parseSend(>, expression)
@@ -772,9 +772,9 @@
         parseFieldInitializerOpt(operators_asterisk, operators_asterisk, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -787,9 +787,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -800,9 +800,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -814,9 +814,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -827,9 +827,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -842,9 +842,9 @@
                                           listener: handleNoArguments(*)
                                         listener: handleSend(, *)
                                   listener: beginBinaryExpression(*)
-                                  parsePrecedenceExpression(*, 15, true)
-                                    parseUnaryExpression(*, true)
-                                      parsePrimary(*, expression)
+                                  parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                      parsePrimary(*, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(*, expression)
                                           parseSend(*, expression)
                                             isNextIdentifier(*)
@@ -875,9 +875,9 @@
         parseFieldInitializerOpt(operators_bang_openBracket, operators_bang_openBracket, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -890,9 +890,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -903,9 +903,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -917,9 +917,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -930,17 +930,17 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrecedenceExpression(!, 16, true)
-                                      parseUnaryExpression(!, true)
-                                        parsePrimary(!, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(!, true, ConstantPatternContext.none)
+                                        parsePrimary(!, expression, ConstantPatternContext.none)
                                           listener: handleNoTypeArguments([)
                                           parseLiteralListSuffix(!, null)
                                             parseExpression([)
-                                              parsePrecedenceExpression([, 1, true)
-                                                parseUnaryExpression([, true)
-                                                  parsePrimary([, expression)
+                                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                  parsePrimary([, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral([, expression)
                                                       parseSend([, expression)
                                                         isNextIdentifier([)
@@ -972,9 +972,9 @@
         parseFieldInitializerOpt(operators_bang_paren, operators_bang_paren, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -987,9 +987,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1000,9 +1000,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1014,9 +1014,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1027,18 +1027,18 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrecedenceExpression(!, 16, true)
-                                      parseUnaryExpression(!, true)
-                                        parsePrimary(!, expression)
-                                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!)
-                                            parseParenthesizedExpressionOrRecordLiteral(!, null)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(!, true, ConstantPatternContext.none)
+                                        parsePrimary(!, expression, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionOrRecordLiteral(!, null, ConstantPatternContext.none)
                                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                                               parseExpression(()
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()
@@ -1071,9 +1071,9 @@
         parseFieldInitializerOpt(operators_bar, operators_bar, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1086,9 +1086,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1099,9 +1099,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1113,9 +1113,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1126,9 +1126,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -1141,9 +1141,9 @@
                                           listener: handleNoArguments(|)
                                         listener: handleSend(, |)
                                   listener: beginBinaryExpression(|)
-                                  parsePrecedenceExpression(|, 10, true)
-                                    parseUnaryExpression(|, true)
-                                      parsePrimary(|, expression)
+                                  parsePrecedenceExpression(|, 10, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(|, true, ConstantPatternContext.none)
+                                      parsePrimary(|, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
                                             isNextIdentifier(|)
@@ -1174,9 +1174,9 @@
         parseFieldInitializerOpt(operators_caret, operators_caret, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1189,9 +1189,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1202,9 +1202,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1216,9 +1216,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1229,9 +1229,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -1244,9 +1244,9 @@
                                           listener: handleNoArguments(^)
                                         listener: handleSend(, ^)
                                   listener: beginBinaryExpression(^)
-                                  parsePrecedenceExpression(^, 11, true)
-                                    parseUnaryExpression(^, true)
-                                      parsePrimary(^, expression)
+                                  parsePrecedenceExpression(^, 11, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(^, true, ConstantPatternContext.none)
+                                      parsePrimary(^, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
                                             isNextIdentifier(^)
@@ -1277,9 +1277,9 @@
         parseFieldInitializerOpt(operators_is, operators_is, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1292,9 +1292,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1305,9 +1305,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1319,9 +1319,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1332,9 +1332,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       inPlainSync()
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
@@ -1376,9 +1376,9 @@
         parseFieldInitializerOpt(operators_lessThan, operators_lessThan, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1389,9 +1389,9 @@
                         listener: handleNoArguments(<)
                       listener: handleSend(f, <)
               listener: beginBinaryExpression(<)
-              parsePrecedenceExpression(<, 9, true)
-                parseUnaryExpression(<, true)
-                  parsePrimary(<, expression)
+              parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                parseUnaryExpression(<, true, ConstantPatternContext.none)
+                  parsePrimary(<, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(<, expression)
                       parseSend(<, expression)
                         isNextIdentifier(<)
@@ -1405,9 +1405,9 @@
               reportRecoverableError(>, EqualityCannotBeEqualityOperand)
                 listener: handleRecoverableError(EqualityCannotBeEqualityOperand, >, >)
               listener: beginBinaryExpression(>)
-              parsePrecedenceExpression(>, 9, true)
-                parseUnaryExpression(>, true)
-                  parsePrimary(>, expression)
+              parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                parseUnaryExpression(>, true, ConstantPatternContext.none)
+                  parsePrimary(>, expression, ConstantPatternContext.none)
                     parseLiteralListSetMapOrFunction(>, null)
                       listener: beginTypeArguments(<)
                       listener: handleIdentifier(b, typeReference)
@@ -1440,9 +1440,9 @@
         parseFieldInitializerOpt(operators_minus, operators_minus, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1455,9 +1455,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1468,9 +1468,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1482,9 +1482,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1495,11 +1495,11 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrecedenceExpression(-, 16, true)
-                                      parseUnaryExpression(-, true)
-                                        parsePrimary(-, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                        parsePrimary(-, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(-, expression)
                                             parseSend(-, expression)
                                               isNextIdentifier(-)
@@ -1530,9 +1530,9 @@
         parseFieldInitializerOpt(operators_openBracket, operators_openBracket, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1545,9 +1545,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1558,9 +1558,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1572,9 +1572,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1585,15 +1585,15 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       listener: handleNoTypeArguments([)
                                       parseLiteralListSuffix(>, null)
                                         parseExpression([)
-                                          parsePrecedenceExpression([, 1, true)
-                                            parseUnaryExpression([, true)
-                                              parsePrimary([, expression)
+                                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                                              parsePrimary([, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral([, expression)
                                                   parseSend([, expression)
                                                     isNextIdentifier([)
@@ -1624,9 +1624,9 @@
         parseFieldInitializerOpt(operators_openBracket_error, operators_openBracket_error, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1639,9 +1639,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1652,9 +1652,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1666,9 +1666,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1679,15 +1679,15 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       listener: handleNoTypeArguments([)
                                       parseLiteralListSuffix(>, null)
                                         parseExpression([)
-                                          parsePrecedenceExpression([, 1, true)
-                                            parseUnaryExpression([, true)
-                                              parsePrimary([, expression)
+                                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                                              parsePrimary([, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral([, expression)
                                                   parseSend([, expression)
                                                     isNextIdentifier([)
@@ -1702,9 +1702,9 @@
                                 reportRecoverableError(>, EqualityCannotBeEqualityOperand)
                                   listener: handleRecoverableError(EqualityCannotBeEqualityOperand, >, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(>, expression)
                                         parseSend(>, expression)
                                           isNextIdentifier(>)
@@ -1734,9 +1734,9 @@
         parseFieldInitializerOpt(operators_openBracket_unambiguous, operators_openBracket_unambiguous, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1749,9 +1749,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1762,9 +1762,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1776,9 +1776,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1789,15 +1789,15 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       listener: handleNoTypeArguments([)
                                       parseLiteralListSuffix(>, null)
                                         parseExpression([)
-                                          parsePrecedenceExpression([, 1, true)
-                                            parseUnaryExpression([, true)
-                                              parsePrimary([, expression)
+                                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                                              parsePrimary([, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral([, expression)
                                                   parseSend([, expression)
                                                     isNextIdentifier([)
@@ -1808,9 +1808,9 @@
                                                       listener: handleNoArguments(,)
                                                     listener: handleSend(d, ,)
                                         parseExpression(,)
-                                          parsePrecedenceExpression(,, 1, true)
-                                            parseUnaryExpression(,, true)
-                                              parsePrimary(,, expression)
+                                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                              parsePrimary(,, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral(,, expression)
                                                   parseSend(,, expression)
                                                     isNextIdentifier(,)
@@ -1841,9 +1841,9 @@
         parseFieldInitializerOpt(operators_percent, operators_percent, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1856,9 +1856,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1869,9 +1869,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1883,9 +1883,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1896,9 +1896,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -1911,9 +1911,9 @@
                                           listener: handleNoArguments(%)
                                         listener: handleSend(, %)
                                   listener: beginBinaryExpression(%)
-                                  parsePrecedenceExpression(%, 15, true)
-                                    parseUnaryExpression(%, true)
-                                      parsePrimary(%, expression)
+                                  parsePrecedenceExpression(%, 15, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(%, true, ConstantPatternContext.none)
+                                      parsePrimary(%, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(%, expression)
                                           parseSend(%, expression)
                                             isNextIdentifier(%)
@@ -1944,9 +1944,9 @@
         parseFieldInitializerOpt(operators_period_period, operators_period_period, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -1959,9 +1959,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -1972,9 +1972,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -1986,9 +1986,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -1999,9 +1999,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2049,9 +2049,9 @@
         parseFieldInitializerOpt(operators_plus, operators_plus, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2064,9 +2064,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2077,9 +2077,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2091,9 +2091,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2104,13 +2104,13 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
                                     rewriteAndRecover(>, UnsupportedPrefixPlus, )
                                       reportRecoverableError(+, UnsupportedPrefixPlus)
                                         listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
                                       rewriter()
-                                    parsePrimary(>, expression)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(>, expression)
                                         parseSend(>, expression)
                                           isNextIdentifier(>)
@@ -2121,9 +2121,9 @@
                                             listener: handleNoArguments(+)
                                           listener: handleSend(, +)
                                   listener: beginBinaryExpression(+)
-                                  parsePrecedenceExpression(+, 14, true)
-                                    parseUnaryExpression(+, true)
-                                      parsePrimary(+, expression)
+                                  parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                      parsePrimary(+, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(+, expression)
                                           parseSend(+, expression)
                                             isNextIdentifier(+)
@@ -2154,9 +2154,9 @@
         parseFieldInitializerOpt(operators_question, operators_question, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2169,9 +2169,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2182,9 +2182,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2196,9 +2196,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2209,9 +2209,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2227,17 +2227,17 @@
                                 parseConditionalExpressionRest()
                                   listener: beginConditionalExpression(?)
                                   parseExpressionWithoutCascade(?)
-                                    parsePrecedenceExpression(?, 1, false)
-                                      parseUnaryExpression(?, false)
-                                        parsePrimary(?, expression)
+                                    parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                        parsePrimary(?, expression, ConstantPatternContext.none)
                                           parseLiteralNull(?)
                                             listener: handleLiteralNull(null)
                                   ensureColon(null)
                                   listener: handleConditionalExpressionColon()
                                   parseExpressionWithoutCascade(:)
-                                    parsePrecedenceExpression(:, 1, false)
-                                      parseUnaryExpression(:, false)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralNull(:)
                                             listener: handleLiteralNull(null)
                                   listener: endConditionalExpression(?, :)
@@ -2260,9 +2260,9 @@
         parseFieldInitializerOpt(operators_question_period_methodInvocation, operators_question_period_methodInvocation, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2275,9 +2275,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2288,9 +2288,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2302,9 +2302,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2315,9 +2315,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2329,7 +2329,7 @@
                                         parseArgumentsOpt()
                                           listener: handleNoArguments(?.)
                                         listener: handleSend(, ?.)
-                                  parsePrimary(?., expressionContinuation)
+                                  parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(?., expressionContinuation)
                                       looksLikeFunctionBody())
                                       parseSend(?., expressionContinuation)
@@ -2364,9 +2364,9 @@
         parseFieldInitializerOpt(operators_question_period_methodInvocation_generic, operators_question_period_methodInvocation_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2379,9 +2379,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2392,9 +2392,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2406,9 +2406,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2419,9 +2419,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2433,7 +2433,7 @@
                                         parseArgumentsOpt()
                                           listener: handleNoArguments(?.)
                                         listener: handleSend(, ?.)
-                                  parsePrimary(?., expressionContinuation)
+                                  parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(?., expressionContinuation)
                                       looksLikeFunctionBody())
                                       parseSend(?., expressionContinuation)
@@ -2472,9 +2472,9 @@
         parseFieldInitializerOpt(operators_question_period_period, operators_question_period_period, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2487,9 +2487,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2500,9 +2500,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2514,9 +2514,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2527,9 +2527,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2547,9 +2547,9 @@
                                 listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], toString, toString)
                               rewriter()
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       looksLikeFunctionBody())
                                       parseSend(,, expression)
@@ -2582,9 +2582,9 @@
         parseFieldInitializerOpt(operators_question_period_propertyAccess, operators_question_period_propertyAccess, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2597,9 +2597,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2610,9 +2610,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2624,9 +2624,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2637,9 +2637,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2651,7 +2651,7 @@
                                         parseArgumentsOpt()
                                           listener: handleNoArguments(?.)
                                         listener: handleSend(, ?.)
-                                  parsePrimary(?., expressionContinuation)
+                                  parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(?., expressionContinuation)
                                       parseSend(?., expressionContinuation)
                                         isNextIdentifier(?.)
@@ -2682,9 +2682,9 @@
         parseFieldInitializerOpt(operators_question_question, operators_question_question, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2697,9 +2697,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2710,9 +2710,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2724,9 +2724,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2737,9 +2737,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2753,9 +2753,9 @@
                                         listener: handleSend(, ??)
                                 listener: endBinaryExpression(>)
                                 listener: beginBinaryExpression(??)
-                                parsePrecedenceExpression(??, 5, true)
-                                  parseUnaryExpression(??, true)
-                                    parsePrimary(??, expression)
+                                parsePrecedenceExpression(??, 5, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(??, true, ConstantPatternContext.none)
+                                    parsePrimary(??, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(??, expression)
                                         parseSend(??, expression)
                                           isNextIdentifier(??)
@@ -2785,9 +2785,9 @@
         parseFieldInitializerOpt(operators_slash, operators_slash, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2800,9 +2800,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2813,9 +2813,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2827,9 +2827,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2840,9 +2840,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2855,9 +2855,9 @@
                                           listener: handleNoArguments(/)
                                         listener: handleSend(, /)
                                   listener: beginBinaryExpression(/)
-                                  parsePrecedenceExpression(/, 15, true)
-                                    parseUnaryExpression(/, true)
-                                      parsePrimary(/, expression)
+                                  parsePrecedenceExpression(/, 15, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(/, true, ConstantPatternContext.none)
+                                      parsePrimary(/, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(/, expression)
                                           parseSend(/, expression)
                                             isNextIdentifier(/)
@@ -2888,9 +2888,9 @@
         parseFieldInitializerOpt(operators_tilde_slash, operators_tilde_slash, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(;)
                     parseSend(=, expression)
@@ -2903,9 +2903,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -2916,9 +2916,9 @@
                                           listener: handleNoArguments(<)
                                         listener: handleSend(a, <)
                                 listener: beginBinaryExpression(<)
-                                parsePrecedenceExpression(<, 9, true)
-                                  parseUnaryExpression(<, true)
-                                    parsePrimary(<, expression)
+                                parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                    parsePrimary(<, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(<, expression)
                                         parseSend(<, expression)
                                           isNextIdentifier(<)
@@ -2930,9 +2930,9 @@
                                           listener: handleSend(b, ,)
                                 listener: endBinaryExpression(<)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -2943,9 +2943,9 @@
                                           listener: handleNoArguments(>)
                                         listener: handleSend(c, >)
                                 listener: beginBinaryExpression(>)
-                                parsePrecedenceExpression(>, 9, true)
-                                  parseUnaryExpression(>, true)
-                                    parsePrimary(>, expression)
+                                parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                    parsePrimary(>, expression, ConstantPatternContext.none)
                                       parseSend(>, expression)
                                         isNextIdentifier(>)
                                         ensureIdentifier(>, expression)
@@ -2958,9 +2958,9 @@
                                           listener: handleNoArguments(~/)
                                         listener: handleSend(, ~/)
                                   listener: beginBinaryExpression(~/)
-                                  parsePrecedenceExpression(~/, 15, true)
-                                    parseUnaryExpression(~/, true)
-                                      parsePrimary(~/, expression)
+                                  parsePrecedenceExpression(~/, 15, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(~/, true, ConstantPatternContext.none)
+                                      parsePrimary(~/, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(~/, expression)
                                           parseSend(~/, expression)
                                             isNextIdentifier(~/)

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

diff --git a/pkg/front_end/parser_testcases/general/function_reference_kinds.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/function_reference_kinds.dart.intertwined.expect
index 53ec6e5..0df97c4 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_kinds.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_kinds.dart.intertwined.expect
@@ -16,9 +16,9 @@
         parseFieldInitializerOpt(simpleIdentifier, simpleIdentifier, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -54,9 +54,9 @@
         parseFieldInitializerOpt(method, method, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     looksLikeFunctionBody(.)
                     parseSend(=, expression)
@@ -70,7 +70,7 @@
                             listener: beginArguments(()
                             listener: endArguments(0, (, ))
                       listener: handleSend(f, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -107,9 +107,9 @@
         parseFieldInitializerOpt(prefixedIdentifier, prefixedIdentifier, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -119,7 +119,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -156,9 +156,9 @@
         parseFieldInitializerOpt(three_identifiers, three_identifiers, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -168,7 +168,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -179,7 +179,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(ClassName, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect
index 9dbe6ef..2c7eb9a 100644
--- a/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect
@@ -82,9 +82,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -95,9 +95,9 @@
                                       listener: handleNoArguments(!=)
                                     listener: handleSend(configuration, !=)
                             listener: beginBinaryExpression(!=)
-                            parsePrecedenceExpression(!=, 8, true)
-                              parseUnaryExpression(!=, true)
-                                parsePrimary(!=, expression)
+                            parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                              parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                                parsePrimary(!=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(!=)
                                     listener: handleLiteralNull(null)
                             listener: endBinaryExpression(!=)
@@ -107,9 +107,9 @@
                       listener: beginInitializer(_configuration)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -119,9 +119,9 @@
                                     parseArgumentsOpt(_configuration)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(_configuration, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -182,9 +182,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -195,9 +195,9 @@
                                       listener: handleNoArguments(!=)
                                     listener: handleSend(configuration, !=)
                             listener: beginBinaryExpression(!=)
-                            parsePrecedenceExpression(!=, 8, true)
-                              parseUnaryExpression(!=, true)
-                                parsePrimary(!=, expression)
+                            parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                              parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                                parsePrimary(!=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(!=)
                                     listener: handleLiteralNull(null)
                             listener: endBinaryExpression(!=)
@@ -207,9 +207,9 @@
                       listener: beginInitializer(_configuration)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -219,9 +219,9 @@
                                     parseArgumentsOpt(_configuration)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(_configuration, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -282,9 +282,9 @@
                       parseAssert(:, Assert.Initializer)
                         listener: beginAssert(assert, Assert.Initializer)
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -295,9 +295,9 @@
                                       listener: handleNoArguments(!=)
                                     listener: handleSend(_configuration, !=)
                             listener: beginBinaryExpression(!=)
-                            parsePrecedenceExpression(!=, 8, true)
-                              parseUnaryExpression(!=, true)
-                                parsePrimary(!=, expression)
+                            parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                              parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                                parsePrimary(!=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(!=)
                                     listener: handleLiteralNull(null)
                             listener: endBinaryExpression(!=)
@@ -307,9 +307,9 @@
                       listener: beginInitializer(_configuration)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -319,9 +319,9 @@
                                     parseArgumentsOpt(_configuration)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(_configuration, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -331,7 +331,7 @@
                                       parseArgumentsOpt(_configuration)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(_configuration, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -358,9 +358,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
                                     isNextIdentifier(return)
@@ -409,9 +409,9 @@
                       listener: beginInitializer(_configuration)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -421,9 +421,9 @@
                                     parseArgumentsOpt(_configuration)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(_configuration, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -470,9 +470,9 @@
                       listener: beginInitializer(_configuration)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -482,9 +482,9 @@
                                     parseArgumentsOpt(_configuration)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(_configuration, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -556,9 +556,9 @@
                 parseFunctionBody(foo, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseThisExpression(=>, expression)
                               listener: handleThisExpression(this, expression)
                     ensureSemicolon(this)

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

diff --git a/pkg/front_end/parser_testcases/general/issue_45120.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45120.dart.intertwined.expect
index a497a72..5e89585 100644
--- a/pkg/front_end/parser_testcases/general/issue_45120.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45120.dart.intertwined.expect
@@ -20,9 +20,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralInt(()
                         listener: handleLiteralInt(0)
               listener: endArguments(1, (, ))
@@ -52,9 +52,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralInt(()
                             listener: handleLiteralInt(0)
                   listener: endArguments(1, (, ))
@@ -86,9 +86,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralInt(()
                             listener: handleLiteralInt(0)
                   listener: endArguments(1, (, ))
@@ -126,9 +126,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(0)
                         listener: endArguments(1, (, ))
@@ -190,9 +190,9 @@
                         parseArgumentsRest(()
                           listener: beginArguments(()
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(0)
                           listener: endArguments(1, (, ))
@@ -219,9 +219,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(0)
                             listener: endArguments(1, (, ))
@@ -256,9 +256,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(0)
                                   listener: endArguments(1, (, ))
@@ -283,9 +283,9 @@
                       parseVariableInitializerOpt(f)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralNull(=)
                                   listener: handleLiteralNull(null)
                         listener: endVariableInitializer(=)

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

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 87b74a9..4bb1136 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
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b=)
@@ -177,9 +177,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -192,9 +192,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -205,9 +205,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(x, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -219,16 +219,16 @@
                                                   listener: handleSend(y, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                              parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -295,9 +295,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -310,22 +310,22 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(,)
                                                 listener: beginFunctionExpression(()
@@ -340,9 +340,9 @@
                                                   parseFunctionBody(), true, false)
                                                     parseExpressionFunctionBody(=>, true)
                                                       parseExpression(=>)
-                                                        parsePrecedenceExpression(=>, 1, true)
-                                                          parseUnaryExpression(=>, true)
-                                                            parsePrimary(=>, expression)
+                                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                                               parseLiteralInt(=>)
                                                                 listener: handleLiteralInt(2)
                                                       listener: handleExpressionFunctionBody(=>, null)

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

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 c3ca3d3..73e45b6 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
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b=)
@@ -177,9 +177,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -192,16 +192,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -212,9 +212,9 @@
                                                               listener: handleNoArguments(<)
                                                             listener: handleSend(x, <)
                                                     listener: beginBinaryExpression(<)
-                                                    parsePrecedenceExpression(<, 9, true)
-                                                      parseUnaryExpression(<, true)
-                                                        parsePrimary(<, expression)
+                                                    parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                                        parsePrimary(<, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral(<, expression)
                                                             parseSend(<, expression)
                                                               isNextIdentifier(<)
@@ -228,16 +228,16 @@
                                                 ensureCloseParen(y, ()
                                                 listener: endParenthesizedExpression(()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                              parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -304,9 +304,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -319,22 +319,22 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(,)
                                                 listener: beginFunctionExpression(()
@@ -349,9 +349,9 @@
                                                   parseFunctionBody(), true, false)
                                                     parseExpressionFunctionBody(=>, true)
                                                       parseExpression(=>)
-                                                        parsePrecedenceExpression(=>, 1, true)
-                                                          parseUnaryExpression(=>, true)
-                                                            parsePrimary(=>, expression)
+                                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                                               parseLiteralInt(=>)
                                                                 listener: handleLiteralInt(2)
                                                       listener: handleExpressionFunctionBody(=>, null)

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

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 b3f8fb2..c90aa7e 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
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -177,9 +177,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -192,9 +192,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -206,9 +206,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(x, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -220,22 +220,22 @@
                                                   listener: handleSend(y, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(0)
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>, null)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
                                                               isNextIdentifier(()
@@ -296,9 +296,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -311,21 +311,21 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     listener: endArguments(3, (, ))

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

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 f1f40c1..371ea48 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
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -177,9 +177,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -192,16 +192,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -212,9 +212,9 @@
                                                               listener: handleNoArguments(<)
                                                             listener: handleSend(x, <)
                                                     listener: beginBinaryExpression(<)
-                                                    parsePrecedenceExpression(<, 9, true)
-                                                      parseUnaryExpression(<, true)
-                                                        parsePrimary(<, expression)
+                                                    parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                                        parsePrimary(<, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral(<, expression)
                                                             parseSend(<, expression)
                                                               isNextIdentifier(<)
@@ -228,22 +228,22 @@
                                                 ensureCloseParen(y, ()
                                                 listener: endParenthesizedExpression(()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(0)
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>, null)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
                                                               isNextIdentifier(()
@@ -304,9 +304,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -319,21 +319,21 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     listener: endArguments(3, (, ))

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

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 5b8efa6..9cc8752 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
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -189,9 +189,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -204,9 +204,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -218,9 +218,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(x, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -232,16 +232,16 @@
                                                   listener: handleSend(y, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                              parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -263,16 +263,16 @@
                                                 ensureCloseParen(int, ()
                                                 listener: endParenthesizedExpression(()
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>, null)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
                                                               isNextIdentifier(()
@@ -333,9 +333,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -348,27 +348,27 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(3)
                                     listener: endArguments(4, (, ))

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

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 b8a7446..879c84f 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
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -189,9 +189,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -204,16 +204,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -224,9 +224,9 @@
                                                               listener: handleNoArguments(<)
                                                             listener: handleSend(x, <)
                                                     listener: beginBinaryExpression(<)
-                                                    parsePrecedenceExpression(<, 9, true)
-                                                      parseUnaryExpression(<, true)
-                                                        parsePrimary(<, expression)
+                                                    parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                                        parsePrimary(<, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral(<, expression)
                                                             parseSend(<, expression)
                                                               isNextIdentifier(<)
@@ -240,16 +240,16 @@
                                                 ensureCloseParen(y, ()
                                                 listener: endParenthesizedExpression(()
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                              parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral((, expression)
                                                           parseSend((, expression)
                                                             isNextIdentifier(()
@@ -271,16 +271,16 @@
                                                 ensureCloseParen(int, ()
                                                 listener: endParenthesizedExpression(()
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>, null)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
                                                               isNextIdentifier(()
@@ -341,9 +341,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -356,27 +356,27 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(3)
                                     listener: endArguments(4, (, ))

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

diff --git a/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect
index bb3a329..7ea8d1b 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect
@@ -67,9 +67,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)

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

diff --git a/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect
index f102562..c9ac539 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect
@@ -67,9 +67,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)

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

diff --git a/pkg/front_end/parser_testcases/general/issue_45848_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_05.dart.intertwined.expect
index d2f5029..1307393 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_05.dart.intertwined.expect
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -189,9 +189,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -204,9 +204,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -226,9 +226,9 @@
                                                     parseArgumentsRest(()
                                                       listener: beginArguments(()
                                                       parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
+                                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                            parsePrimary((, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
                                                                   isNextIdentifier(()
@@ -336,9 +336,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -351,9 +351,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -373,9 +373,9 @@
                                                     parseArgumentsRest(()
                                                       listener: beginArguments(()
                                                       parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
+                                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                            parsePrimary((, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
                                                                   isNextIdentifier(()
@@ -426,9 +426,9 @@
                 looksLikeLocalFunction(g1)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -441,27 +441,27 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(3)
                                     listener: endArguments(4, (, ))
@@ -475,9 +475,9 @@
                 looksLikeLocalFunction(g2)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -490,27 +490,27 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(3)
                                     listener: endArguments(4, (, ))

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

diff --git a/pkg/front_end/parser_testcases/general/issue_45848_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_06.dart.intertwined.expect
index 8469fd9..73c682d 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_06.dart.intertwined.expect
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -188,9 +188,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -203,9 +203,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -236,9 +236,9 @@
                                                     parseArgumentsRest(()
                                                       listener: beginArguments(()
                                                       parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
+                                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                            parsePrimary((, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
                                                                   isNextIdentifier(()
@@ -297,9 +297,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -312,27 +312,27 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(3)
                                     listener: endArguments(4, (, ))
@@ -404,9 +404,9 @@
                     parseReturnStatement({)
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
                               parseLiteralBool(return)
                                 listener: handleLiteralBool(true)
                       ensureSemicolon(true)

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

diff --git a/pkg/front_end/parser_testcases/general/issue_45848_07.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_07.dart.intertwined.expect
index a360e74..e96a828 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_07.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_07.dart.intertwined.expect
@@ -56,9 +56,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -71,9 +71,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('b1=)
@@ -213,9 +213,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -228,9 +228,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -270,9 +270,9 @@
                                                     parseArgumentsRest(()
                                                       listener: beginArguments(()
                                                       parseExpression(()
-                                                        parsePrecedenceExpression((, 1, true)
-                                                          parseUnaryExpression((, true)
-                                                            parsePrimary((, expression)
+                                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                            parsePrimary((, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
                                                                   isNextIdentifier(()
@@ -283,9 +283,9 @@
                                                                     listener: handleNoArguments(,)
                                                                   listener: handleSend(c, ,)
                                                       parseExpression(,)
-                                                        parsePrecedenceExpression(,, 1, true)
-                                                          parseUnaryExpression(,, true)
-                                                            parsePrimary(,, expression)
+                                                        parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                            parsePrimary(,, expression, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral(,, expression)
                                                                 parseSend(,, expression)
                                                                   isNextIdentifier(,)
@@ -336,9 +336,9 @@
                 looksLikeLocalFunction(g)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -351,39 +351,39 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(0)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(3)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(5)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(6)
                                     listener: endArguments(6, (, ))

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

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 ab5fbf7..e7a1107 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
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -62,9 +62,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(b, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -76,9 +76,9 @@
                                                   listener: handleSend(c, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -89,9 +89,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(d, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -103,22 +103,22 @@
                                                   listener: handleSend(e, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                         listener: beginBinaryExpression(>>)
-                                        parsePrecedenceExpression(>>, 13, true)
-                                          parseUnaryExpression(>>, true)
-                                            parsePrimary(>>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>>, null)
+                                        parsePrecedenceExpression(>>, 13, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>, true, ConstantPatternContext.none)
+                                            parsePrimary(>>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(()
                                                             listener: handleLiteralInt(2)
                                                   ensureCloseParen(2, ()

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

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 8d6d4c3..19f04b9 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
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -62,9 +62,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(b, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -76,9 +76,9 @@
                                                   listener: handleSend(c, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -89,9 +89,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(d, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -103,9 +103,9 @@
                                                   listener: handleSend(e, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -116,9 +116,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(f, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -130,22 +130,22 @@
                                                   listener: handleSend(g, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(1)
                                         listener: beginBinaryExpression(>>>)
-                                        parsePrecedenceExpression(>>>, 13, true)
-                                          parseUnaryExpression(>>>, true)
-                                            parsePrimary(>>>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>>>, null)
+                                        parsePrecedenceExpression(>>>, 13, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>>, true, ConstantPatternContext.none)
+                                            parsePrimary(>>>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(()
                                                             listener: handleLiteralInt(2)
                                                   ensureCloseParen(2, ()

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

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 d1b5921..afc1783 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
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -62,9 +62,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(b, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -76,9 +76,9 @@
                                                   listener: handleSend(c, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             inPlainSync()
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
@@ -91,16 +91,16 @@
                                                   listener: handleNoArguments(>)
                                                 listener: handleSend(as, >)
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>, null)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(()
                                                             listener: handleLiteralInt(1)
                                                   ensureCloseParen(1, ()

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

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 db0cda0..38e0984 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
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -62,9 +62,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(b, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -76,9 +76,9 @@
                                                   listener: handleSend(c, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -89,9 +89,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(d, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -103,9 +103,9 @@
                                                   listener: handleSend(e, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             inPlainSync()
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
@@ -118,16 +118,16 @@
                                                   listener: handleNoArguments(>>)
                                                 listener: handleSend(as, >>)
                                         listener: beginBinaryExpression(>>)
-                                        parsePrecedenceExpression(>>, 13, true)
-                                          parseUnaryExpression(>>, true)
-                                            parsePrimary(>>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>>, null)
+                                        parsePrecedenceExpression(>>, 13, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>, true, ConstantPatternContext.none)
+                                            parsePrimary(>>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(()
                                                             listener: handleLiteralInt(1)
                                                   ensureCloseParen(1, ()

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

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 bf2114a..94f0c8c 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
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
@@ -62,9 +62,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(b, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -76,9 +76,9 @@
                                                   listener: handleSend(c, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -89,9 +89,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(d, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -103,9 +103,9 @@
                                                   listener: handleSend(e, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
                                                 isNextIdentifier(,)
@@ -116,9 +116,9 @@
                                                   listener: handleNoArguments(<)
                                                 listener: handleSend(f, <)
                                         listener: beginBinaryExpression(<)
-                                        parsePrecedenceExpression(<, 9, true)
-                                          parseUnaryExpression(<, true)
-                                            parsePrimary(<, expression)
+                                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                                            parsePrimary(<, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
                                                   isNextIdentifier(<)
@@ -130,9 +130,9 @@
                                                   listener: handleSend(g, ,)
                                         listener: endBinaryExpression(<)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             inPlainSync()
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
@@ -145,16 +145,16 @@
                                                   listener: handleNoArguments(>>>)
                                                 listener: handleSend(as, >>>)
                                         listener: beginBinaryExpression(>>>)
-                                        parsePrecedenceExpression(>>>, 13, true)
-                                          parseUnaryExpression(>>>, true)
-                                            parsePrimary(>>>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>>>, null)
+                                        parsePrecedenceExpression(>>>, 13, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>>, true, ConstantPatternContext.none)
+                                            parsePrimary(>>>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>>>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>>>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(()
                                                             listener: handleLiteralInt(1)
                                                   ensureCloseParen(1, ()

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

diff --git a/pkg/front_end/parser_testcases/general/metadata.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/metadata.dart.intertwined.expect
index 5fa4d2e..e0f8bc1 100644
--- a/pkg/front_end/parser_testcases/general/metadata.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/metadata.dart.intertwined.expect
@@ -56,9 +56,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -81,9 +81,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -108,9 +108,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -132,9 +132,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -159,9 +159,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -187,9 +187,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -218,9 +218,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -563,9 +563,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -595,9 +595,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -633,9 +633,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -684,9 +684,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -721,9 +721,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -764,9 +764,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -817,9 +817,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -856,9 +856,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -901,9 +901,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -951,9 +951,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -987,9 +987,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1029,9 +1029,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -1082,9 +1082,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1121,9 +1121,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1166,9 +1166,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -1220,9 +1220,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1260,9 +1260,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1306,9 +1306,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -1363,9 +1363,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1406,9 +1406,9 @@
                 parseArgumentsRest(()
                   listener: beginArguments(()
                   parseExpression(()
-                    parsePrecedenceExpression((, 1, true)
-                      parseUnaryExpression((, true)
-                        parsePrimary((, expression)
+                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                        parsePrimary((, expression, ConstantPatternContext.none)
                           parseLiteralString(()
                             parseSingleLiteralString(()
                               listener: beginLiteralString("hello")
@@ -1455,9 +1455,9 @@
                       parseArgumentsRest(()
                         listener: beginArguments(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralString(()
                                   parseSingleLiteralString(()
                                     listener: beginLiteralString("hello")
@@ -1524,9 +1524,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -1550,9 +1550,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -1578,9 +1578,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -1603,9 +1603,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -1631,9 +1631,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -1660,9 +1660,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")
@@ -1692,9 +1692,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseLiteralString(()
                         parseSingleLiteralString(()
                           listener: beginLiteralString("hello")

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

diff --git a/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect
index b481b7a..01b447d 100644
--- a/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,9 +48,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("Hello, World!")

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

diff --git a/pkg/front_end/parser_testcases/general/new_as_identifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/new_as_identifier.dart.intertwined.expect
index 7057155..e18fe11 100644
--- a/pkg/front_end/parser_testcases/general/new_as_identifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/new_as_identifier.dart.intertwined.expect
@@ -101,9 +101,9 @@
                       rewriter()
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -113,12 +113,12 @@
                                     parseArgumentsOpt()
                                       listener: handleNoArguments(=)
                                     listener: handleSend(, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseThisExpression(=, expression)
                                     listener: handleThisExpression(this, expression)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -281,9 +281,9 @@
                 parseFunctionBody(), false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               looksLikeFunctionBody(;)
                               parseSend(=>, expression)
@@ -523,12 +523,12 @@
                         listener: handleNewAsIdentifier(new)
                         parseInitializerExpressionRest(:)
                           parseExpression(:)
-                            parsePrecedenceExpression(:, 1, true)
-                              parseUnaryExpression(:, true)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                parsePrimary(:, expression, ConstantPatternContext.none)
                                   parseSuperExpression(:, expression)
                                     listener: handleSuperExpression(super, expression)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -585,12 +585,12 @@
                       listener: handleNewAsIdentifier(new)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseThisExpression(:, expression)
                                   listener: handleThisExpression(this, expression)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -632,9 +632,9 @@
         parseFieldInitializerOpt(constructor_invocation_const, constructor_invocation_const, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseConstExpression(=)
                     listener: beginConstExpression(const)
                     parseConstructorReference(const, ConstructorReferenceContext.Const, null)
@@ -673,9 +673,9 @@
         parseFieldInitializerOpt(constructor_invocation_const_generic, constructor_invocation_const_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseConstExpression(=)
                     listener: beginConstExpression(const)
                     parseConstructorReference(const, ConstructorReferenceContext.Const, null)
@@ -715,9 +715,9 @@
         parseFieldInitializerOpt(constructor_invocation_const_prefixed, constructor_invocation_const_prefixed, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseConstExpression(=)
                     listener: beginConstExpression(const)
                     parseConstructorReference(const, ConstructorReferenceContext.Const, null)
@@ -757,9 +757,9 @@
         parseFieldInitializerOpt(constructor_invocation_const_prefixed_generic, constructor_invocation_const_prefixed_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseConstExpression(=)
                     listener: beginConstExpression(const)
                     parseConstructorReference(const, ConstructorReferenceContext.Const, null)
@@ -803,9 +803,9 @@
         parseFieldInitializerOpt(constructor_invocation_explicit, constructor_invocation_explicit, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseNewExpression(=)
                     isNextIdentifier(new)
                     listener: beginNewExpression(new)
@@ -845,9 +845,9 @@
         parseFieldInitializerOpt(constructor_invocation_explicit_generic, constructor_invocation_explicit_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseNewExpression(=)
                     isNextIdentifier(new)
                     listener: beginNewExpression(new)
@@ -888,9 +888,9 @@
         parseFieldInitializerOpt(constructor_invocation_explicit_prefixed, constructor_invocation_explicit_prefixed, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseNewExpression(=)
                     isNextIdentifier(new)
                     listener: beginNewExpression(new)
@@ -931,9 +931,9 @@
         parseFieldInitializerOpt(constructor_invocation_explicit_prefixed_generic, constructor_invocation_explicit_prefixed_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseNewExpression(=)
                     isNextIdentifier(new)
                     listener: beginNewExpression(new)
@@ -978,9 +978,9 @@
         parseFieldInitializerOpt(constructor_invocation_implicit, constructor_invocation_implicit, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -990,7 +990,7 @@
                       parseArgumentsOpt(C)
                         listener: handleNoArguments(.)
                       listener: handleSend(C, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1024,8 +1024,8 @@
         parseFieldInitializerOpt(constructor_invocation_implicit_generic, constructor_invocation_implicit_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
                 parseImplicitCreationExpression(=, <, Instance of 'SimpleTypeArgument1')
                   listener: beginImplicitCreationExpression(C)
                   parseConstructorReference(=, ConstructorReferenceContext.Implicit, Instance of 'SimpleTypeArgument1')
@@ -1065,9 +1065,9 @@
         parseFieldInitializerOpt(constructor_invocation_implicit_prefixed, constructor_invocation_implicit_prefixed, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1077,7 +1077,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -1088,7 +1088,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(C, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1122,8 +1122,8 @@
         parseFieldInitializerOpt(constructor_invocation_implicit_prefixed_generic, constructor_invocation_implicit_prefixed_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
                 parseImplicitCreationExpression(=, <, Instance of 'SimpleTypeArgument1')
                   listener: beginImplicitCreationExpression(prefix)
                   parseConstructorReference(=, ConstructorReferenceContext.Implicit, Instance of 'SimpleTypeArgument1')
@@ -1167,9 +1167,9 @@
         parseFieldInitializerOpt(constructor_tearoff, constructor_tearoff, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1179,7 +1179,7 @@
                       parseArgumentsOpt(C)
                         listener: handleNoArguments(.)
                       listener: handleSend(C, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1209,9 +1209,9 @@
         parseFieldInitializerOpt(constructor_tearoff_generic, constructor_tearoff_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1227,7 +1227,7 @@
               listener: handleType(int, null)
               listener: endTypeArguments(1, <, >)
               listener: handleTypeArgumentApplication(<)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1257,9 +1257,9 @@
         parseFieldInitializerOpt(constructor_tearoff_generic_method_invocation, constructor_tearoff_generic_method_invocation, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1275,7 +1275,7 @@
               listener: handleType(int, null)
               listener: endTypeArguments(1, <, >)
               listener: handleTypeArgumentApplication(<)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1288,7 +1288,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(new, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   looksLikeFunctionBody(;)
                   parseSend(., expressionContinuation)
@@ -1320,9 +1320,9 @@
         parseFieldInitializerOpt(constructor_tearoff_method_invocation, constructor_tearoff_method_invocation, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1332,7 +1332,7 @@
                       parseArgumentsOpt(C)
                         listener: handleNoArguments(.)
                       listener: handleSend(C, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1345,7 +1345,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(new, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   looksLikeFunctionBody(;)
                   parseSend(., expressionContinuation)
@@ -1377,9 +1377,9 @@
         parseFieldInitializerOpt(constructor_tearoff_prefixed, constructor_tearoff_prefixed, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1389,7 +1389,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -1400,7 +1400,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(C, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1430,9 +1430,9 @@
         parseFieldInitializerOpt(constructor_tearoff_prefixed_generic, constructor_tearoff_prefixed_generic, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1442,7 +1442,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -1459,7 +1459,7 @@
               listener: handleType(int, null)
               listener: endTypeArguments(1, <, >)
               listener: handleTypeArgumentApplication(<)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1489,9 +1489,9 @@
         parseFieldInitializerOpt(constructor_tearoff_prefixed_generic_method_invocation, constructor_tearoff_prefixed_generic_method_invocation, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1501,7 +1501,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -1518,7 +1518,7 @@
               listener: handleType(int, null)
               listener: endTypeArguments(1, <, >)
               listener: handleTypeArgumentApplication(<)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1531,7 +1531,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(new, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   looksLikeFunctionBody(;)
                   parseSend(., expressionContinuation)
@@ -1563,9 +1563,9 @@
         parseFieldInitializerOpt(constructor_tearoff_prefixed_method_invocation, constructor_tearoff_prefixed_method_invocation, null, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(=, expression)
                     parseSend(=, expression)
                       isNextIdentifier(=)
@@ -1575,7 +1575,7 @@
                       parseArgumentsOpt(prefix)
                         listener: handleNoArguments(.)
                       listener: handleSend(prefix, .)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   parseSend(., expressionContinuation)
                     isNextIdentifier(.)
@@ -1586,7 +1586,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(C, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 rewriter()
                 listener: handleNewAsIdentifier(new)
                 parseSendOrFunctionLiteral(., expressionContinuation)
@@ -1599,7 +1599,7 @@
                       listener: handleNoArguments(.)
                     listener: handleSend(new, .)
               listener: handleEndingBinaryExpression(.)
-              parsePrimary(., expressionContinuation)
+              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                 parseSendOrFunctionLiteral(., expressionContinuation)
                   looksLikeFunctionBody(;)
                   parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/general/operator_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/operator_01.dart.intertwined.expect
index 5e70cbc..882b750 100644
--- a/pkg/front_end/parser_testcases/general/operator_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/operator_01.dart.intertwined.expect
@@ -71,9 +71,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralBool(return)
                                   listener: handleLiteralBool(true)
                         ensureSemicolon(true)
@@ -129,9 +129,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(42)
                         ensureSemicolon(42)
@@ -187,9 +187,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralBool(return)
                                   listener: handleLiteralBool(true)
                         ensureSemicolon(true)
@@ -245,9 +245,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(42)
                         ensureSemicolon(42)
@@ -303,9 +303,9 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
                                 parseLiteralInt(return)
                                   listener: handleLiteralInt(42)
                         ensureSemicolon(42)

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

diff --git a/pkg/front_end/parser_testcases/general/toplevel_get_called_get.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/toplevel_get_called_get.dart.intertwined.expect
index 27765cc..8ea4a7e 100644
--- a/pkg/front_end/parser_testcases/general/toplevel_get_called_get.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/toplevel_get_called_get.dart.intertwined.expect
@@ -27,9 +27,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -72,9 +72,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -111,9 +111,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -156,9 +156,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -195,9 +195,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -241,9 +241,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -280,9 +280,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -326,9 +326,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect
index 29edd5a..eb46dde 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect
index 3dd4671..a846c9a 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect
index cadd54f..3f947d0 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -57,7 +57,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(e, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect
index 5971d1e..2c757f8 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -57,7 +57,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(e, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)

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

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 d54a621..6923bef 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
@@ -45,16 +45,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -97,16 +97,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()

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

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 ed97a48..67e8405 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
@@ -45,16 +45,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -65,7 +65,7 @@
                                               listener: handleNoArguments(!)
                                             listener: handleSend(e, !)
                                     listener: handleNonNullAssertExpression(!)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         looksLikeFunctionBody())
                                         parseSend(., expressionContinuation)
@@ -104,16 +104,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -124,7 +124,7 @@
                                               listener: handleNoArguments(!)
                                             listener: handleSend(e, !)
                                     listener: handleNonNullAssertExpression(!)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         looksLikeFunctionBody(!)
                                         parseSend(., expressionContinuation)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect
index 0d9261a..4870319 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -57,7 +57,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(e, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect
index 430fd1a..b113f9f 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -57,7 +57,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(e, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect
index ead9c0c..b2e68ad 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -58,9 +58,9 @@
                               listener: handleSend(e, [)
                       parseArgumentOrIndexStar(e, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -80,9 +80,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -103,9 +103,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -118,9 +118,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -142,9 +142,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect
index aff6bab..8732df9 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect
index ded0c9c..9a5708d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -86,9 +86,9 @@
                         listener: handleEndingBinaryExpression(.)
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralString([)
                                     parseSingleLiteralString([)
                                       listener: beginLiteralString('Hi!')
@@ -126,9 +126,9 @@
                         parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                         parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                         parseExpressionWithoutCascade(=)
-                          parsePrecedenceExpression(=, 1, false)
-                            parseUnaryExpression(=, false)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(=, false, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(2)
                         listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect
index d53d81c..db8a34f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -84,9 +84,9 @@
                         listener: handleEndingBinaryExpression(.)
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralString([)
                                     parseSingleLiteralString([)
                                       listener: beginLiteralString('Hi!')
@@ -120,9 +120,9 @@
                         parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                         parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                         parseExpressionWithoutCascade(=)
-                          parsePrecedenceExpression(=, 1, false)
-                            parseUnaryExpression(=, false)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(=, false, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(2)
                         listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect
index 4fa031c..e58b9ab 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect
index c9ecdbc..499abae 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 looksLikeLocalFunction(c)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -64,20 +64,20 @@
                               parseArgumentsOpt(c)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(c, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                           listener: handleLiteralList(1, [, null, ])
                       listener: handleEndingBinaryExpression(?.)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)
@@ -90,9 +90,9 @@
                 looksLikeLocalFunction(c)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -104,30 +104,30 @@
                               listener: handleSend(c, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
-                            parsePrecedenceExpression(=, 1, false)
-                              parseUnaryExpression(=, false)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(=, false, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                       parseArgumentOrIndexStar(c, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(1)
                         listener: handleIndexedExpression(?, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)
@@ -140,9 +140,9 @@
                 looksLikeLocalFunction(c)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -154,30 +154,30 @@
                               listener: handleSend(c, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
-                            parsePrecedenceExpression(=, 1, false)
-                              parseUnaryExpression(=, false)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(=, false, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                       parseArgumentOrIndexStar(c, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(1)
                         listener: handleIndexedExpression(?, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect
index d451892..1dabaed 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect
@@ -25,9 +25,9 @@
         parseFunctionBody(log, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
                         isNextIdentifier(=>)
@@ -37,7 +37,7 @@
                         parseArgumentsOpt(Zone)
                           listener: handleNoArguments(.)
                         listener: handleSend(Zone, .)
-                parsePrimary(., expressionContinuation)
+                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     parseSend(., expressionContinuation)
                       isNextIdentifier(.)
@@ -50,9 +50,9 @@
                 listener: handleEndingBinaryExpression(.)
                 parseArgumentOrIndexStar(current, Instance of 'NoTypeParamOrArg', false)
                   parseExpression([)
-                    parsePrecedenceExpression([, 1, true)
-                      parseUnaryExpression([, true)
-                        parsePrimary([, expression)
+                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                        parsePrimary([, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral([, expression)
                             parseSend([, expression)
                               isNextIdentifier([)
@@ -73,9 +73,9 @@
                   listener: handleAsOperator(as)
                   skipChainedAsIsOperators(?)
                 listener: beginBinaryExpression(??)
-                parsePrecedenceExpression(??, 5, true)
-                  parseUnaryExpression(??, true)
-                    parsePrimary(??, expression)
+                parsePrecedenceExpression(??, 5, true, ConstantPatternContext.none)
+                  parseUnaryExpression(??, true, ConstantPatternContext.none)
+                    parsePrimary(??, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(??, expression)
                         parseSend(??, expression)
                           isNextIdentifier(??)

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

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 957b665..29c5c2b 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
@@ -25,16 +25,16 @@
         parseFunctionBody(log, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
                                     isNextIdentifier(()
@@ -44,7 +44,7 @@
                                     parseArgumentsOpt(Zone)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(Zone, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
                                   isNextIdentifier(.)
@@ -57,9 +57,9 @@
                             listener: handleEndingBinaryExpression(.)
                             parseArgumentOrIndexStar(current, Instance of 'NoTypeParamOrArg', false)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral([, expression)
                                         parseSend([, expression)
                                           isNextIdentifier([)
@@ -82,9 +82,9 @@
                         ensureCloseParen(?, ()
                         listener: endParenthesizedExpression(()
                 listener: beginBinaryExpression(??)
-                parsePrecedenceExpression(??, 5, true)
-                  parseUnaryExpression(??, true)
-                    parsePrimary(??, expression)
+                parsePrecedenceExpression(??, 5, true, ConstantPatternContext.none)
+                  parseUnaryExpression(??, true, ConstantPatternContext.none)
+                    parsePrimary(??, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(??, expression)
                         parseSend(??, expression)
                           isNextIdentifier(??)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect
index b9def80..ddde1e8 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect
@@ -64,9 +64,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -115,9 +115,9 @@
               parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                 looksLikeLocalFunction(a)
                 parseExpressionWithoutCascade(=)
-                  parsePrecedenceExpression(=, 1, false)
-                    parseUnaryExpression(=, false)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                    parseUnaryExpression(=, false, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseLiteralNull(=)
                 listener: beginMetadataStar(A)
                 listener: endMetadataStar(0)
@@ -133,9 +133,9 @@
                     parseVariableInitializerOpt(a)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralNull(=)
                                 listener: handleLiteralNull(null)
                       listener: endVariableInitializer(=)
@@ -149,9 +149,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -162,7 +162,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(a, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(?., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(?., expressionContinuation)
@@ -186,9 +186,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -199,13 +199,13 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(a, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(42)
                           listener: handleLiteralList(1, [, null, ])
@@ -219,9 +219,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -234,20 +234,20 @@
                       listener: handleNonNullAssertExpression(!)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(42)
                         listener: handleIndexedExpression(?, [, ])
@@ -260,9 +260,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -275,20 +275,20 @@
                       listener: handleNonNullAssertExpression(!)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(42)
                         listener: handleIndexedExpression(?, [, ])

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

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 2927f68..89d0850 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
@@ -64,9 +64,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -115,9 +115,9 @@
               parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                 looksLikeLocalFunction(a)
                 parseExpressionWithoutCascade(=)
-                  parsePrecedenceExpression(=, 1, false)
-                    parseUnaryExpression(=, false)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                    parseUnaryExpression(=, false, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseLiteralNull(=)
                 listener: beginMetadataStar(A)
                 listener: endMetadataStar(0)
@@ -133,9 +133,9 @@
                     parseVariableInitializerOpt(a)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralNull(=)
                                 listener: handleLiteralNull(null)
                       listener: endVariableInitializer(=)
@@ -150,16 +150,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -172,7 +172,7 @@
                                     listener: handleNonNullAssertExpression(!)
                                 ensureCloseParen(!, ()
                                 listener: endParenthesizedExpression(()
-                        parsePrimary(?., expressionContinuation)
+                        parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(?., expressionContinuation)
                             looksLikeFunctionBody(;)
                             parseSend(?., expressionContinuation)
@@ -197,16 +197,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -219,13 +219,13 @@
                                     listener: handleNonNullAssertExpression(!)
                                 ensureCloseParen(!, ()
                                 listener: endParenthesizedExpression(()
-                        parsePrimary(?., expressionContinuation)
+                        parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                           listener: handleNoTypeArguments([)
                           parseLiteralListSuffix(?., null)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralInt([)
                                       listener: handleLiteralInt(42)
                             listener: handleLiteralList(1, [, null, ])
@@ -240,16 +240,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -264,20 +264,20 @@
                                 listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
-                            parsePrecedenceExpression(?, 1, false)
-                              parseUnaryExpression(?, false)
-                                parsePrimary(?, expression)
+                            parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                parsePrimary(?, expression, ConstantPatternContext.none)
                                   parseLiteralListSuffix(?, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralInt([)
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', true)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(42)
                           listener: handleIndexedExpression(?, [, ])
@@ -291,16 +291,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -315,20 +315,20 @@
                                 listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
-                            parsePrecedenceExpression(?, 1, false)
-                              parseUnaryExpression(?, false)
-                                parsePrimary(?, expression)
+                            parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                parsePrimary(?, expression, ConstantPatternContext.none)
                                   parseLiteralListSuffix(?, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralInt([)
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', true)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(42)
                           listener: handleIndexedExpression(?, [, ])

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect
index 9fc11b2..c1242e3 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect
@@ -40,9 +40,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralString(=>)
                       parseSingleLiteralString(=>)
                         listener: beginLiteralString("42")
@@ -98,9 +98,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -139,9 +139,9 @@
                 parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                   looksLikeLocalFunction(f1)
                   parseExpressionWithoutCascade(=)
-                    parsePrecedenceExpression(=, 1, false)
-                      parseUnaryExpression(=, false)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                      parseUnaryExpression(=, false, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
@@ -161,9 +161,9 @@
                       parseVariableInitializerOpt(f1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -184,9 +184,9 @@
                 looksLikeLocalFunction(f1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -203,9 +203,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             listener: endArguments(1, (, ))
@@ -232,9 +232,9 @@
                       parseVariableInitializerOpt(f2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -255,9 +255,9 @@
                 looksLikeLocalFunction(f2)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -278,9 +278,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             listener: endArguments(1, (, ))

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect
index 0fa70fa..253900b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect
@@ -40,9 +40,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralString(=>)
                       parseSingleLiteralString(=>)
                         listener: beginLiteralString("42")
@@ -98,9 +98,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -139,9 +139,9 @@
                 parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                   looksLikeLocalFunction(f1)
                   parseExpressionWithoutCascade(=)
-                    parsePrecedenceExpression(=, 1, false)
-                      parseUnaryExpression(=, false)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                      parseUnaryExpression(=, false, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
@@ -161,9 +161,9 @@
                       parseVariableInitializerOpt(f1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -184,9 +184,9 @@
                 looksLikeLocalFunction(f1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -203,9 +203,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             listener: endArguments(1, (, ))
@@ -232,9 +232,9 @@
                       parseVariableInitializerOpt(f2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -255,9 +255,9 @@
                 looksLikeLocalFunction(f2)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -274,9 +274,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     listener: endArguments(1, (, ))

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

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 c71bafd..e4bba39 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
@@ -40,9 +40,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralString(=>)
                       parseSingleLiteralString(=>)
                         listener: beginLiteralString("42")
@@ -98,9 +98,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -139,9 +139,9 @@
                 parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                   looksLikeLocalFunction(f1)
                   parseExpressionWithoutCascade(=)
-                    parsePrecedenceExpression(=, 1, false)
-                      parseUnaryExpression(=, false)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                      parseUnaryExpression(=, false, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)
@@ -161,9 +161,9 @@
                       parseVariableInitializerOpt(f1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -184,9 +184,9 @@
                 looksLikeLocalFunction(f1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -203,9 +203,9 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             listener: endArguments(1, (, ))
@@ -232,9 +232,9 @@
                       parseVariableInitializerOpt(f2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -256,16 +256,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -288,9 +288,9 @@
                             parseArgumentsRest(()
                               listener: beginArguments(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               listener: endArguments(1, (, ))

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect
index cedc2b9..1dfb169 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect
@@ -70,9 +70,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -124,9 +124,9 @@
                       parseVariableInitializerOpt(f2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -147,9 +147,9 @@
                 looksLikeLocalFunction(f2)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -173,15 +173,15 @@
                           parseArgumentsRest(()
                             listener: beginArguments(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseLiteralString(,)
                                       parseSingleLiteralString(,)
                                         listener: beginLiteralString("42")

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect
index f15d0ca..e6f9bee 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect
@@ -70,9 +70,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -124,9 +124,9 @@
                       parseVariableInitializerOpt(f2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)
@@ -147,9 +147,9 @@
                 looksLikeLocalFunction(f2)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -169,15 +169,15 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("42")

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime5.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime5.dart.intertwined.expect
index 242f5b2..ab5b32a 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime5.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime5.dart.intertwined.expect
@@ -29,9 +29,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -74,9 +74,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime6.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime6.dart.intertwined.expect
index 4dfc115..13bd32d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime6.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime6.dart.intertwined.expect
@@ -27,9 +27,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)
@@ -70,9 +70,9 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseLiteralInt(=>)
                       listener: handleLiteralInt(42)
             ensureSemicolon(42)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39858.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39858.dart.intertwined.expect
index 53b46ba..7d0cfe2 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39858.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39858.dart.intertwined.expect
@@ -96,9 +96,9 @@
                 parseFieldInitializerOpt(x4, x4, late, null, null, null, null, DeclarationKind.Class, X)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -121,9 +121,9 @@
                 parseFieldInitializerOpt(x5, x5, late, null, null, null, null, DeclarationKind.Class, X)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -146,9 +146,9 @@
                 parseFieldInitializerOpt(x6, x6, late, null, null, null, null, DeclarationKind.Class, X)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39858_prime1.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39858_prime1.dart.intertwined.expect
index 9a58d9b..581480f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39858_prime1.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39858_prime1.dart.intertwined.expect
@@ -84,9 +84,9 @@
                 parseFieldInitializerOpt(x4, x4, null, null, null, null, var, DeclarationKind.Class, X)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -106,9 +106,9 @@
                 parseFieldInitializerOpt(x5, x5, null, null, null, null, var, DeclarationKind.Class, X)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)
@@ -128,9 +128,9 @@
                 parseFieldInitializerOpt(x6, x6, null, null, null, null, var, DeclarationKind.Class, X)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(0)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect
index 4dc8335..cc6c274 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect
@@ -34,9 +34,9 @@
                 ensureParenthesizedCondition(switch, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -55,9 +55,9 @@
                   peekPastLabels(case)
                   listener: beginCaseExpression(case)
                   parseExpression(case)
-                    parsePrecedenceExpression(case, 1, true)
-                      parseUnaryExpression(case, true)
-                        parsePrimary(case, expression)
+                    parsePrecedenceExpression(case, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(case, true, ConstantPatternContext.none)
+                        parsePrimary(case, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
                               isNextIdentifier(case)
@@ -69,23 +69,23 @@
                               listener: handleSend(b, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(c)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -94,15 +94,15 @@
                       parseConditionalExpressionRest(b)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -116,9 +116,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -141,9 +141,9 @@
                           looksLikeLocalFunction(e)
                           parseExpressionStatement(:)
                             parseExpression(:)
-                              parsePrecedenceExpression(:, 1, true)
-                                parseUnaryExpression(:, true)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(:, expression)
                                       parseSend(:, expression)
                                         isNextIdentifier(:)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect
index 66c08b7..54f9db0 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect
@@ -34,9 +34,9 @@
                 ensureParenthesizedCondition(switch, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -55,9 +55,9 @@
                   peekPastLabels(case)
                   listener: beginCaseExpression(case)
                   parseExpression(case)
-                    parsePrecedenceExpression(case, 1, true)
-                      parseUnaryExpression(case, true)
-                        parsePrimary(case, expression)
+                    parsePrecedenceExpression(case, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(case, true, ConstantPatternContext.none)
+                        parsePrimary(case, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
                               isNextIdentifier(case)
@@ -69,33 +69,33 @@
                               listener: handleSend(b, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(c)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralSetOrMapSuffix(:, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralSetOrMapSuffix({, null)
                                             parseExpression({)
-                                              parsePrecedenceExpression({, 1, true)
-                                                parseUnaryExpression({, true)
-                                                  parsePrimary({, expression)
+                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                     inPlainSync()
                                                     parseSend({, expression)
                                                       isNextIdentifier({)
@@ -106,9 +106,9 @@
                                             reportRecoverableError(break, Message[ExpectedButGot, Expected '}' before this., null, {string: }}])
                       parseArgumentOrIndexStar(b, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect
index 50e2f8b..7814881 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect
@@ -34,9 +34,9 @@
                 ensureParenthesizedCondition(switch, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -55,9 +55,9 @@
                   peekPastLabels(case)
                   listener: beginCaseExpression(case)
                   parseExpression(case)
-                    parsePrecedenceExpression(case, 1, true)
-                      parseUnaryExpression(case, true)
-                        parsePrimary(case, expression)
+                    parsePrecedenceExpression(case, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(case, true, ConstantPatternContext.none)
+                        parsePrimary(case, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
                               isNextIdentifier(case)
@@ -69,19 +69,19 @@
                               listener: handleSend(x, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -90,24 +90,24 @@
                       parseConditionalExpressionRest(x)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                                             listener: handleLiteralInt(4)
                                   listener: handleLiteralList(1, [, null, ])
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect
index 670ab6c..fc227fa 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect
@@ -34,9 +34,9 @@
                 ensureParenthesizedCondition(switch, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -55,9 +55,9 @@
                   peekPastLabels(case)
                   listener: beginCaseExpression(case)
                   parseExpression(case)
-                    parsePrecedenceExpression(case, 1, true)
-                      parseUnaryExpression(case, true)
-                        parsePrimary(case, expression)
+                    parsePrecedenceExpression(case, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(case, true, ConstantPatternContext.none)
+                        parsePrimary(case, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
                               isNextIdentifier(case)
@@ -69,74 +69,74 @@
                               listener: handleSend(x, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralSetOrMapSuffix(:, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralSetOrMapSuffix({, null)
                                             parseExpression({)
-                                              parsePrecedenceExpression({, 1, true)
-                                                parseUnaryExpression({, true)
-                                                  parsePrimary({, expression)
+                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                     parseLiteralSetOrMapSuffix({, null)
                                                       parseExpression({)
-                                                        parsePrecedenceExpression({, 1, true)
-                                                          parseUnaryExpression({, true)
-                                                            parsePrimary({, expression)
+                                                        parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                            parsePrimary({, expression, ConstantPatternContext.none)
                                                               parseLiteralInt({)
                       parseConditionalExpressionRest(x)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                                             listener: handleLiteralInt(4)
                                   listener: handleLiteralList(1, [, null, ])
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments({)
                                 parseLiteralSetOrMapSuffix(:, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           listener: handleNoTypeArguments({)
                                           parseLiteralSetOrMapSuffix({, null)
                                             parseExpression({)
-                                              parsePrecedenceExpression({, 1, true)
-                                                parseUnaryExpression({, true)
-                                                  parsePrimary({, expression)
+                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                     listener: handleNoTypeArguments({)
                                                     parseLiteralSetOrMapSuffix({, null)
                                                       parseExpression({)
-                                                        parsePrecedenceExpression({, 1, true)
-                                                          parseUnaryExpression({, true)
-                                                            parsePrimary({, expression)
+                                                        parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                            parsePrimary({, expression, ConstantPatternContext.none)
                                                               parseLiteralInt({)
                                                                 listener: handleLiteralInt(2)
                                                       listener: handleLiteralSetOrMap(1, {, null, }, true)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect
index 3b7b622..6180c79 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect
@@ -34,9 +34,9 @@
                 ensureParenthesizedCondition(switch, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -55,9 +55,9 @@
                   peekPastLabels(case)
                   listener: beginCaseExpression(case)
                   parseExpression(case)
-                    parsePrecedenceExpression(case, 1, true)
-                      parseUnaryExpression(case, true)
-                        parsePrimary(case, expression)
+                    parsePrecedenceExpression(case, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(case, true, ConstantPatternContext.none)
+                        parsePrimary(case, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
                               isNextIdentifier(case)
@@ -69,41 +69,41 @@
                               listener: handleSend(x, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralSetOrMapSuffix(:, null)
                                   parseExpression({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralSetOrMapSuffix({, null)
                                             parseExpression({)
-                                              parsePrecedenceExpression({, 1, true)
-                                                parseUnaryExpression({, true)
-                                                  parsePrimary({, expression)
+                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                     parseLiteralSetOrMapSuffix({, null)
                                                       parseExpression({)
-                                                        parsePrecedenceExpression({, 1, true)
-                                                          parseUnaryExpression({, true)
-                                                            parsePrimary({, expression)
+                                                        parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                            parsePrimary({, expression, ConstantPatternContext.none)
                                                               parseLiteralInt({)
                                                       reportRecoverableError(;, Message[ExpectedButGot, Expected '}' before this., null, {string: }}])
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(4)
                         listener: handleIndexedExpression(?, [, ])
@@ -138,9 +138,9 @@
                                               looksLikeLocalFunction(2)
                                               parseExpressionStatement({)
                                                 parseExpression({)
-                                                  parsePrecedenceExpression({, 1, true)
-                                                    parseUnaryExpression({, true)
-                                                      parsePrimary({, expression)
+                                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                      parsePrimary({, expression, ConstantPatternContext.none)
                                                         parseLiteralInt({)
                                                           listener: handleLiteralInt(2)
                                                 ensureSemicolon(2)

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

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 23116f8..c62103b 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
@@ -66,9 +66,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -80,23 +80,23 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -105,15 +105,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -127,9 +127,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -149,9 +149,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -163,23 +163,23 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -188,15 +188,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -210,9 +210,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -232,9 +232,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -246,20 +246,20 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -269,9 +269,9 @@
                                     parseArguments(toString)
                                       parseArgumentsRest(()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -280,15 +280,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -299,7 +299,7 @@
                                                 listener: handleNoArguments(])
                                               listener: handleSend(b, ])
                                   listener: handleLiteralList(1, [, null, ])
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -317,9 +317,9 @@
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -339,9 +339,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -353,20 +353,20 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -376,9 +376,9 @@
                                     parseArguments(toString)
                                       parseArgumentsRest(()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -387,15 +387,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -406,7 +406,7 @@
                                                 listener: handleNoArguments(])
                                               listener: handleSend(b, ])
                                   listener: handleLiteralList(1, [, null, ])
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -424,9 +424,9 @@
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -446,9 +446,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -461,9 +461,9 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(?, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(dynamic, typeReference)
@@ -472,9 +472,9 @@
                                   listener: endTypeArguments(1, <, >)
                                   parseLiteralListSuffix(>, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
                                                 isNextIdentifier([)
@@ -488,9 +488,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(:, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(dynamic, typeReference)
@@ -499,9 +499,9 @@
                                   listener: endTypeArguments(1, <, >)
                                   parseLiteralListSuffix(>, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
                                                 isNextIdentifier([)
@@ -522,9 +522,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -537,22 +537,22 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?)
-                                  parseParenthesizedExpressionOrRecordLiteral(?, null)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(?, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             listener: handleNoTypeArguments([)
                                             parseLiteralListSuffix((, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
                                                           isNextIdentifier([)
@@ -568,22 +568,22 @@
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                  parseParenthesizedExpressionOrRecordLiteral(:, null)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             listener: handleNoTypeArguments([)
                                             parseLiteralListSuffix((, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
                                                           isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect
index 1d255ea..2ce7480 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect
@@ -58,9 +58,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
                             isNextIdentifier(return)
@@ -72,14 +72,14 @@
                             listener: handleSend(a, ?)
                     canParseAsConditional(?)
                       parseExpressionWithoutCascade(?)
-                        parsePrecedenceExpression(?, 1, false)
-                          parseUnaryExpression(?, false)
-                            parsePrimary(?, expression)
+                        parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(?, false, ConstantPatternContext.none)
+                            parsePrimary(?, expression, ConstantPatternContext.none)
                               parseLiteralListSuffix(?, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
@@ -89,30 +89,30 @@
                                               parseArguments(b)
                                                 parseArgumentsRest(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralListSuffix((, null)
                                                             rewriteSquareBrackets(()
                                                               link([, ])
                                                               rewriter()
                       parseExpressionWithoutCascade(:)
-                        parsePrecedenceExpression(:, 1, false)
-                          parseUnaryExpression(:, false)
-                            parsePrimary(:, expression)
+                        parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(:, false, ConstantPatternContext.none)
+                            parsePrimary(:, expression, ConstantPatternContext.none)
                               parseLiteralNull(:)
                     parseConditionalExpressionRest(a)
                       listener: beginConditionalExpression(?)
                       parseExpressionWithoutCascade(?)
-                        parsePrecedenceExpression(?, 1, false)
-                          parseUnaryExpression(?, false)
-                            parsePrimary(?, expression)
+                        parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(?, false, ConstantPatternContext.none)
+                            parsePrimary(?, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(?, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
@@ -125,9 +125,9 @@
                                                 parseArgumentsRest(()
                                                   listener: beginArguments(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           listener: handleNoTypeArguments([])
                                                           parseLiteralListSuffix((, null)
                                                             rewriteSquareBrackets(()
@@ -140,9 +140,9 @@
                       ensureColon(])
                       listener: handleConditionalExpressionColon()
                       parseExpressionWithoutCascade(:)
-                        parsePrecedenceExpression(:, 1, false)
-                          parseUnaryExpression(:, false)
-                            parsePrimary(:, expression)
+                        parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(:, false, ConstantPatternContext.none)
+                            parsePrimary(:, expression, ConstantPatternContext.none)
                               parseLiteralNull(:)
                                 listener: handleLiteralNull(null)
                       listener: endConditionalExpression(?, :)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect
index 4ab77f1..581218f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect
@@ -59,9 +59,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -71,13 +71,13 @@
                               parseArgumentsOpt(a)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(a, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)
@@ -98,9 +98,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -112,14 +112,14 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -127,9 +127,9 @@
                                               parseArgumentsOpt(b)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -149,9 +149,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -163,14 +163,14 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -178,9 +178,9 @@
                                               parseArgumentsOpt(b)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect
index bac8060..54d52e2 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect
@@ -66,9 +66,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -78,13 +78,13 @@
                               parseArgumentsOpt(a)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(a, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)
@@ -96,9 +96,9 @@
                                       listener: handleSend(b, ])
                           listener: handleLiteralList(1, [, null, ])
                       listener: handleEndingBinaryExpression(?.)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)
@@ -118,9 +118,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -132,22 +132,22 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
-                            parsePrecedenceExpression(=, 1, false)
-                              parseUnaryExpression(=, false)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(=, false, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -155,9 +155,9 @@
                                       parseArgumentsOpt(c)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -168,9 +168,9 @@
                                       listener: handleNoArguments(])
                                     listener: handleSend(b, ])
                         listener: handleIndexedExpression(?, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)
@@ -190,9 +190,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -204,22 +204,22 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
-                            parsePrecedenceExpression(=, 1, false)
-                              parseUnaryExpression(=, false)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(=, false, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -227,9 +227,9 @@
                                       parseArgumentsOpt(c)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -240,9 +240,9 @@
                                       listener: handleNoArguments(])
                                     listener: handleSend(b, ])
                         listener: handleIndexedExpression(?, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect
index 80ae21e..d224dec 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect
@@ -45,9 +45,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -59,31 +59,31 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
-                            parsePrecedenceExpression(+, 14, false)
-                              parseUnaryExpression(+, false)
-                                parsePrimary(+, expression)
+                            parsePrecedenceExpression(+, 14, false, ConstantPatternContext.none)
+                              parseUnaryExpression(+, false, ConstantPatternContext.none)
+                                parsePrimary(+, expression, ConstantPatternContext.none)
                                   parseLiteralInt(+)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
                       listener: beginBinaryExpression(+)
-                      parsePrecedenceExpression(+, 14, true)
-                        parseUnaryExpression(+, true)
-                          parsePrimary(+, expression)
+                      parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                        parseUnaryExpression(+, true, ConstantPatternContext.none)
+                          parsePrimary(+, expression, ConstantPatternContext.none)
                             parseLiteralInt(+)
                               listener: handleLiteralInt(1)
                       listener: endBinaryExpression(+)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect
index ca92806..5ef1de2 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect
@@ -57,9 +57,9 @@
                 looksLikeLocalFunction(x)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -71,14 +71,14 @@
                               listener: handleSend(x, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -86,9 +86,9 @@
                                               parseArgumentsOpt(i)
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 c117b4f..9b8b076 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
@@ -59,9 +59,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -71,7 +71,7 @@
                               parseArgumentsOpt(a)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(a, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(?., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(?., expressionContinuation)
@@ -84,9 +84,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -108,9 +108,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -123,16 +123,16 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?)
-                                  parseParenthesizedExpressionOrRecordLiteral(?, null)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(?, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -151,9 +151,9 @@
                             rewriter()
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSend(:, expression)
                                   isNextIdentifier(:)
                                   ensureIdentifier(:, expression)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect
index 325227a..90e0aab 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect
@@ -59,9 +59,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -71,7 +71,7 @@
                               parseArgumentsOpt(a)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(a, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(?., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(?., expressionContinuation)
@@ -88,9 +88,9 @@
                                 parseArgumentsRest(()
                                   listener: beginArguments(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -112,9 +112,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -127,9 +127,9 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(?, null)
                                   listener: beginTypeVariables(<)
                                   listener: beginMetadataStar(Foo)
@@ -175,9 +175,9 @@
                             rewriter()
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSend(:, expression)
                                   isNextIdentifier(:)
                                   ensureIdentifier(:, expression)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect
index 282b834..7861173 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect
@@ -58,11 +58,11 @@
                   looksLikeLocalFunction(++)
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrecedenceExpression(++, 16, true)
-                            parseUnaryExpression(++, true)
-                              parsePrimary(++, expression)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrecedenceExpression(++, 16, true, ConstantPatternContext.none)
+                            parseUnaryExpression(++, true, ConstantPatternContext.none)
+                              parsePrimary(++, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(++, expression)
                                   parseSend(++, expression)
                                     isNextIdentifier(++)
@@ -74,14 +74,14 @@
                                     listener: handleSend(x, ?)
                             canParseAsConditional(?)
                               parseExpressionWithoutCascade(?)
-                                parsePrecedenceExpression(?, 1, false)
-                                  parseUnaryExpression(?, false)
-                                    parsePrimary(?, expression)
+                                parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                  parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                    parsePrimary(?, expression, ConstantPatternContext.none)
                                       parseLiteralListSuffix(?, null)
                                         parseExpression([)
-                                          parsePrecedenceExpression([, 1, true)
-                                            parseUnaryExpression([, true)
-                                              parsePrimary([, expression)
+                                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                                              parsePrimary([, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral([, expression)
                                                   parseSend([, expression)
                                                     isNextIdentifier([)
@@ -89,9 +89,9 @@
                                                     parseArgumentsOpt(i)
                             parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', true)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral([, expression)
                                         parseSend([, expression)
                                           isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect
index 0a00754..edd1c1d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect
@@ -45,9 +45,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -57,7 +57,7 @@
                                 parseArgumentsOpt(sample)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(sample, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -70,9 +70,9 @@
                         listener: handleEndingBinaryExpression(.)
                         listener: handleNonNullAssertExpression(!)
                         listener: beginBinaryExpression(<)
-                        parsePrecedenceExpression(<, 9, true)
-                          parseUnaryExpression(<, true)
-                            parsePrimary(<, expression)
+                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                            parsePrimary(<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<)
                                 listener: handleLiteralInt(10)
                         listener: endBinaryExpression(<)
@@ -91,9 +91,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -106,9 +106,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString('thing!')

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

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 9037465..45ae03a 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
@@ -45,16 +45,16 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -64,7 +64,7 @@
                                             parseArgumentsOpt(sample)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(sample, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -79,9 +79,9 @@
                                 ensureCloseParen(!, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(<)
-                        parsePrecedenceExpression(<, 9, true)
-                          parseUnaryExpression(<, true)
-                            parsePrimary(<, expression)
+                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                            parsePrimary(<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<)
                                 listener: handleLiteralInt(10)
                         listener: endBinaryExpression(<)
@@ -100,9 +100,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -115,9 +115,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString('thing!')

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

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 ab41df2..3f30a45 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
@@ -45,16 +45,16 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -64,7 +64,7 @@
                                             parseArgumentsOpt(sample)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(sample, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -78,9 +78,9 @@
                                 ensureCloseParen(value, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(<)
-                        parsePrecedenceExpression(<, 9, true)
-                          parseUnaryExpression(<, true)
-                            parsePrimary(<, expression)
+                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                            parsePrimary(<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<)
                                 listener: handleLiteralInt(10)
                         listener: endBinaryExpression(<)
@@ -99,9 +99,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -114,9 +114,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString('thing!')

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect
index 1699511..0ae6f87 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect
@@ -45,9 +45,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -57,7 +57,7 @@
                                 parseArgumentsOpt(sample)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(sample, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -69,9 +69,9 @@
                               listener: handleSend(value, <)
                         listener: handleEndingBinaryExpression(.)
                         listener: beginBinaryExpression(<)
-                        parsePrecedenceExpression(<, 9, true)
-                          parseUnaryExpression(<, true)
-                            parsePrimary(<, expression)
+                        parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                          parseUnaryExpression(<, true, ConstantPatternContext.none)
+                            parsePrimary(<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<)
                                 listener: handleLiteralInt(10)
                         listener: endBinaryExpression(<)
@@ -90,9 +90,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -105,9 +105,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString('thing!')

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect
index 913b436a..f83fccf 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -56,7 +56,7 @@
                               parseArgumentsOpt(e)
                                 listener: handleNoArguments(.)
                               listener: handleSend(e, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -68,9 +68,9 @@
                             listener: handleSend(x, <)
                       listener: handleEndingBinaryExpression(.)
                       listener: beginBinaryExpression(<)
-                      parsePrecedenceExpression(<, 9, true)
-                        parseUnaryExpression(<, true)
-                          parsePrimary(<, expression)
+                      parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                        parseUnaryExpression(<, true, ConstantPatternContext.none)
+                          parsePrimary(<, expression, ConstantPatternContext.none)
                             parseLiteralInt(<)
                               listener: handleLiteralInt(10)
                       listener: endBinaryExpression(<)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect
index 59ff519..97a0d8b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect
@@ -44,9 +44,9 @@
                 looksLikeLocalFunction(e)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -56,7 +56,7 @@
                               parseArgumentsOpt(e)
                                 listener: handleNoArguments(.)
                               listener: handleSend(e, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -69,9 +69,9 @@
                       listener: handleEndingBinaryExpression(.)
                       listener: handleNonNullAssertExpression(!)
                       listener: beginBinaryExpression(<)
-                      parsePrecedenceExpression(<, 9, true)
-                        parseUnaryExpression(<, true)
-                          parsePrimary(<, expression)
+                      parsePrecedenceExpression(<, 9, true, ConstantPatternContext.none)
+                        parseUnaryExpression(<, true, ConstantPatternContext.none)
+                          parsePrimary(<, expression, ConstantPatternContext.none)
                             parseLiteralInt(<)
                               listener: handleLiteralInt(10)
                       listener: endBinaryExpression(<)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40805_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40805_02.dart.intertwined.expect
index 87ca661..4f78074 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40805_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40805_02.dart.intertwined.expect
@@ -43,9 +43,9 @@
                 parseFieldInitializerOpt(x, x, late, null, null, null, final, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40805_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40805_03.dart.intertwined.expect
index f15342f..b6b5130 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40805_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40805_03.dart.intertwined.expect
@@ -43,9 +43,9 @@
                 parseFieldInitializerOpt(x, x, null, null, null, null, final, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect
index b405f07..52e2d87 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect
@@ -98,9 +98,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -110,9 +110,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -137,9 +137,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -149,9 +149,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                                     listener: handleLiteralInt(0)
                             listener: handleAssignmentExpression(=)
@@ -208,9 +208,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -220,9 +220,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -244,9 +244,9 @@
                               parseConditionalExpressionRest(String)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
                                             isNextIdentifier(?)
@@ -256,7 +256,7 @@
                                             parseArgumentsOpt(o)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(o, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -270,9 +270,9 @@
                                 ensureColon(length)
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: endConditionalExpression(?, :)
@@ -282,9 +282,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -294,9 +294,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -353,9 +353,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -365,9 +365,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -389,9 +389,9 @@
                               parseConditionalExpressionRest(?)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
                                             isNextIdentifier(?)
@@ -401,7 +401,7 @@
                                             parseArgumentsOpt(o)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(o, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -415,9 +415,9 @@
                                 ensureColon(length)
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: endConditionalExpression(?, :)
@@ -427,9 +427,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -439,9 +439,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -498,9 +498,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -510,9 +510,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -534,9 +534,9 @@
                               parseConditionalExpressionRest(String)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
                                             isNextIdentifier(?)
@@ -546,7 +546,7 @@
                                             parseArgumentsOpt(o)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(o, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -560,9 +560,9 @@
                                 ensureColon(length)
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: endConditionalExpression(?, :)
@@ -572,9 +572,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -584,9 +584,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)
@@ -643,9 +643,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -655,9 +655,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -679,9 +679,9 @@
                               parseConditionalExpressionRest(?)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
                                             isNextIdentifier(?)
@@ -691,7 +691,7 @@
                                             parseArgumentsOpt(o)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(o, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -705,9 +705,9 @@
                                 ensureColon(length)
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: endConditionalExpression(?, :)
@@ -717,9 +717,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -729,9 +729,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(=)
                                     listener: handleLiteralNull(null)
                             listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect
index afada63..dd1a5cc 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect
@@ -98,9 +98,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -110,9 +110,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -137,9 +137,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -149,9 +149,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                                     listener: handleLiteralInt(0)
                             listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect
index 7f89d2f..b749de3 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect
@@ -98,9 +98,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -110,9 +110,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -123,18 +123,18 @@
                                         listener: handleNoArguments(!=)
                                       listener: handleSend(o, !=)
                               listener: beginBinaryExpression(!=)
-                              parsePrecedenceExpression(!=, 8, true)
-                                parseUnaryExpression(!=, true)
-                                  parsePrimary(!=, expression)
+                              parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                                parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                                  parsePrimary(!=, expression, ConstantPatternContext.none)
                                     parseLiteralNull(!=)
                                       listener: handleLiteralNull(null)
                               listener: endBinaryExpression(!=)
                               parseConditionalExpressionRest(null)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
                                             isNextIdentifier(?)
@@ -156,9 +156,9 @@
                                 ensureColon(?)
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralNull(:)
                                           listener: handleLiteralNull(null)
                                 listener: endConditionalExpression(?, :)
@@ -168,9 +168,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -180,9 +180,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                                     listener: handleLiteralInt(0)
                             listener: handleAssignmentExpression(=)
@@ -243,9 +243,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -267,23 +267,23 @@
                                 parseConditionalExpressionRest(?)
                                   listener: beginConditionalExpression(?)
                                   parseExpressionWithoutCascade(?)
-                                    parsePrecedenceExpression(?, 1, false)
-                                      parseUnaryExpression(?, false)
-                                        parsePrimary(?, expression)
+                                    parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                        parsePrimary(?, expression, ConstantPatternContext.none)
                                           parseLiteralInt(?)
                                             listener: handleLiteralInt(4)
                                   ensureColon(4)
                                   listener: handleConditionalExpressionColon()
                                   parseExpressionWithoutCascade(:)
-                                    parsePrecedenceExpression(:, 1, false)
-                                      parseUnaryExpression(:, false)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(2)
                                       listener: beginBinaryExpression(==)
-                                      parsePrecedenceExpression(==, 8, false)
-                                        parseUnaryExpression(==, false)
-                                          parsePrimary(==, expression)
+                                      parsePrecedenceExpression(==, 8, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                          parsePrimary(==, expression, ConstantPatternContext.none)
                                             parseLiteralInt(==)
                                               listener: handleLiteralInt(4)
                                       listener: endBinaryExpression(==)
@@ -303,9 +303,9 @@
                                     looksLikeLocalFunction(print)
                                     parseExpressionStatement({)
                                       parseExpression({)
-                                        parsePrecedenceExpression({, 1, true)
-                                          parseUnaryExpression({, true)
-                                            parsePrimary({, expression)
+                                        parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression({, true, ConstantPatternContext.none)
+                                            parsePrimary({, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral({, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend({, expression)
@@ -318,9 +318,9 @@
                                                       parseArgumentsRest(()
                                                         listener: beginArguments(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("hello")
@@ -384,9 +384,9 @@
                         ensureParenthesizedCondition(if, allowCase: false)
                           parseExpressionInParenthesisRest((, allowCase: false)
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
                                         isNextIdentifier(()
@@ -408,23 +408,23 @@
                                 parseConditionalExpressionRest(String)
                                   listener: beginConditionalExpression(?)
                                   parseExpressionWithoutCascade(?)
-                                    parsePrecedenceExpression(?, 1, false)
-                                      parseUnaryExpression(?, false)
-                                        parsePrimary(?, expression)
+                                    parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                        parsePrimary(?, expression, ConstantPatternContext.none)
                                           parseLiteralInt(?)
                                             listener: handleLiteralInt(4)
                                   ensureColon(4)
                                   listener: handleConditionalExpressionColon()
                                   parseExpressionWithoutCascade(:)
-                                    parsePrecedenceExpression(:, 1, false)
-                                      parseUnaryExpression(:, false)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(2)
                                       listener: beginBinaryExpression(==)
-                                      parsePrecedenceExpression(==, 8, false)
-                                        parseUnaryExpression(==, false)
-                                          parsePrimary(==, expression)
+                                      parsePrecedenceExpression(==, 8, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                          parsePrimary(==, expression, ConstantPatternContext.none)
                                             parseLiteralInt(==)
                                               listener: handleLiteralInt(4)
                                       listener: endBinaryExpression(==)
@@ -444,9 +444,9 @@
                                     looksLikeLocalFunction(print)
                                     parseExpressionStatement({)
                                       parseExpression({)
-                                        parsePrecedenceExpression({, 1, true)
-                                          parseUnaryExpression({, true)
-                                            parsePrimary({, expression)
+                                        parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression({, true, ConstantPatternContext.none)
+                                            parsePrimary({, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral({, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend({, expression)
@@ -459,9 +459,9 @@
                                                       parseArgumentsRest(()
                                                         listener: beginArguments(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("hello")

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

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 709e740..1a723d6 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
@@ -61,9 +61,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -76,9 +76,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(null, [, ])
@@ -91,9 +91,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -105,20 +105,20 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
@@ -131,9 +131,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -146,20 +146,20 @@
                       listener: handleNonNullAssertExpression(!)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
@@ -173,16 +173,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -197,20 +197,20 @@
                                 listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
-                            parsePrecedenceExpression(?, 1, false)
-                              parseUnaryExpression(?, false)
-                                parsePrimary(?, expression)
+                            parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                parsePrimary(?, expression, ConstantPatternContext.none)
                                   parseLiteralListSuffix(?, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralInt([)
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', true)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(0)
                           listener: handleIndexedExpression(?, [, ])
@@ -223,9 +223,9 @@
                 looksLikeLocalFunction(b)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -238,41 +238,41 @@
                       listener: handleNonNullAssertExpression(!)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralInt(:)
                       parseConditionalExpressionRest(!)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                                             listener: handleLiteralInt(0)
                                   listener: handleLiteralList(1, [, null, ])
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralInt(:)
                                   listener: handleLiteralInt(0)
                         listener: endConditionalExpression(?, :)
@@ -286,16 +286,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -310,41 +310,41 @@
                                 listener: endParenthesizedExpression(()
                         canParseAsConditional(?)
                           parseExpressionWithoutCascade(?)
-                            parsePrecedenceExpression(?, 1, false)
-                              parseUnaryExpression(?, false)
-                                parsePrimary(?, expression)
+                            parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                parsePrimary(?, expression, ConstantPatternContext.none)
                                   parseLiteralListSuffix(?, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralInt([)
                           parseExpressionWithoutCascade(:)
-                            parsePrecedenceExpression(:, 1, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                parsePrimary(:, expression, ConstantPatternContext.none)
                                   parseLiteralInt(:)
                         parseConditionalExpressionRest())
                           listener: beginConditionalExpression(?)
                           parseExpressionWithoutCascade(?)
-                            parsePrecedenceExpression(?, 1, false)
-                              parseUnaryExpression(?, false)
-                                parsePrimary(?, expression)
+                            parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                parsePrimary(?, expression, ConstantPatternContext.none)
                                   listener: handleNoTypeArguments([)
                                   parseLiteralListSuffix(?, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseLiteralInt([)
                                               listener: handleLiteralInt(0)
                                     listener: handleLiteralList(1, [, null, ])
                           ensureColon(])
                           listener: handleConditionalExpressionColon()
                           parseExpressionWithoutCascade(:)
-                            parsePrecedenceExpression(:, 1, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                parsePrimary(:, expression, ConstantPatternContext.none)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(0)
                           listener: endConditionalExpression(?, :)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect
index 7c74672..e959a9d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect
@@ -67,9 +67,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -82,9 +82,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -105,9 +105,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -120,9 +120,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -144,9 +144,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -159,11 +159,11 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrecedenceExpression(!, 16, true)
-                                            parseUnaryExpression(!, true)
-                                              parsePrimary(!, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(!, true, ConstantPatternContext.none)
+                                              parsePrimary(!, expression, ConstantPatternContext.none)
                                                 parseSendOrFunctionLiteral(!, expression)
                                                   parseSend(!, expression)
                                                     isNextIdentifier(!)
@@ -237,9 +237,9 @@
                       parseSuperInitializerExpression(:)
                         parseInitializerExpressionRest(:)
                           parseExpression(:)
-                            parsePrecedenceExpression(:, 1, true)
-                              parseUnaryExpression(:, true)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                parsePrimary(:, expression, ConstantPatternContext.none)
                                   parseSuperExpression(:, expression)
                                     listener: handleSuperExpression(super, expression)
                                     listener: handleNoTypeArguments(()
@@ -290,9 +290,9 @@
                       parseSuperInitializerExpression(:)
                         parseInitializerExpressionRest(:)
                           parseExpression(:)
-                            parsePrecedenceExpression(:, 1, true)
-                              parseUnaryExpression(:, true)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                parsePrimary(:, expression, ConstantPatternContext.none)
                                   parseSuperExpression(:, expression)
                                     listener: handleSuperExpression(super, expression)
                                     listener: handleNoTypeArguments(()

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

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 c51180c..36c54e5 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
@@ -53,9 +53,9 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
@@ -82,9 +82,9 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -96,9 +96,9 @@
                                   listener: handleSend(json, [)
                           parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralString([)
                                       parseSingleLiteralString([)
                                         listener: beginLiteralString('x')
@@ -128,9 +128,9 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -142,9 +142,9 @@
                                   listener: handleSend(json, [)
                           parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralString([)
                                       parseSingleLiteralString([)
                                         listener: beginLiteralString('y')
@@ -219,9 +219,9 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
@@ -248,9 +248,9 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -262,9 +262,9 @@
                                   listener: handleSend(json, [)
                           parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralString([)
                                       parseSingleLiteralString([)
                                         listener: beginLiteralString('x')
@@ -294,9 +294,9 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -308,9 +308,9 @@
                                   listener: handleSend(json, [)
                           parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralString([)
                                       parseSingleLiteralString([)
                                         listener: beginLiteralString('y')
@@ -385,9 +385,9 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
@@ -414,16 +414,16 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
                                               isNextIdentifier(()
@@ -435,9 +435,9 @@
                                               listener: handleSend(json, [)
                                       parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                                         parseExpression([)
-                                          parsePrecedenceExpression([, 1, true)
-                                            parseUnaryExpression([, true)
-                                              parsePrimary([, expression)
+                                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                                              parsePrimary([, expression, ConstantPatternContext.none)
                                                 parseLiteralString([)
                                                   parseSingleLiteralString([)
                                                     listener: beginLiteralString('x')
@@ -469,9 +469,9 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(y, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -483,9 +483,9 @@
                                   listener: handleSend(json, [)
                           parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralString([)
                                       parseSingleLiteralString([)
                                         listener: beginLiteralString('y')
@@ -560,9 +560,9 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
@@ -589,9 +589,9 @@
                       listener: handleEndingBinaryExpression(..)
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', false)
                       parseExpressionWithoutCascade(=)
-                        parsePrecedenceExpression(=, 1, false)
-                          parseUnaryExpression(=, false)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(=, false, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -603,9 +603,9 @@
                                   listener: handleSend(json, [)
                           parseArgumentOrIndexStar(json, Instance of 'NoTypeParamOrArg', false)
                             parseExpression([)
-                              parsePrecedenceExpression([, 1, true)
-                                parseUnaryExpression([, true)
-                                  parsePrimary([, expression)
+                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                  parsePrimary([, expression, ConstantPatternContext.none)
                                     parseLiteralString([)
                                       parseSingleLiteralString([)
                                         listener: beginLiteralString('x')

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

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 43c140b..306645a 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
@@ -32,10 +32,10 @@
                 parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, null)
                   looksLikeLocalFunction(f)
                   parseExpressionWithoutCascade(=)
-                    parsePrecedenceExpression(=, 1, false)
-                      parseUnaryExpression(=, false)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                    parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                      parseUnaryExpression(=, false, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
                             parseFunctionExpression(=)
                               parseFormalParametersRequiredOpt(=, MemberKind.Local)
                                 parseFormalParametersRest((, MemberKind.Local)
@@ -50,9 +50,9 @@
                                         looksLikeLocalFunction(print)
                                         parseExpressionStatement({)
                                           parseExpression({)
-                                            parsePrecedenceExpression({, 1, true)
-                                              parseUnaryExpression({, true)
-                                                parsePrimary({, expression)
+                                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                parsePrimary({, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral({, expression)
                                                     looksLikeFunctionBody(})
                                                     parseSend({, expression)
@@ -62,9 +62,9 @@
                                                         parseArguments(print)
                                                           parseArgumentsRest(()
                                                             parseExpression(()
-                                                              parsePrecedenceExpression((, 1, true)
-                                                                parseUnaryExpression((, true)
-                                                                  parsePrimary((, expression)
+                                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                                     parseLiteralInt(()
                                           ensureSemicolon())
                                             reportRecoverableError(), Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
@@ -84,10 +84,10 @@
                       parseVariableInitializerOpt(f)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
                                   listener: handleNoTypeVariables(()
                                   parseFunctionExpression(=)
                                     listener: beginFunctionExpression(()
@@ -108,9 +108,9 @@
                                               looksLikeLocalFunction(print)
                                               parseExpressionStatement({)
                                                 parseExpression({)
-                                                  parsePrecedenceExpression({, 1, true)
-                                                    parseUnaryExpression({, true)
-                                                      parsePrimary({, expression)
+                                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                      parsePrimary({, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral({, expression)
                                                           looksLikeFunctionBody(})
                                                           parseSend({, expression)
@@ -123,9 +123,9 @@
                                                                 parseArgumentsRest(()
                                                                   listener: beginArguments(()
                                                                   parseExpression(()
-                                                                    parsePrecedenceExpression((, 1, true)
-                                                                      parseUnaryExpression((, true)
-                                                                        parsePrimary((, expression)
+                                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                                           parseLiteralInt(()
                                                                             listener: handleLiteralInt(1)
                                                                   listener: endArguments(1, (, ))
@@ -149,9 +149,9 @@
                 looksLikeLocalFunction(f)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_48999.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_48999.dart.intertwined.expect
index ad87654..5e71238 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_48999.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_48999.dart.intertwined.expect
@@ -45,9 +45,9 @@
                       parseVariableInitializerOpt(i)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(10)
                         listener: endVariableInitializer(=)
@@ -61,9 +61,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -76,16 +76,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString(')
                                                 parseExpression(${)
-                                                  parsePrecedenceExpression(${, 1, true)
-                                                    parseUnaryExpression(${, true)
-                                                      parsePrimary(${, expression)
+                                                  parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                      parsePrimary(${, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral(${, expression)
                                                           parseSend(${, expression)
                                                             isNextIdentifier(${)
@@ -119,9 +119,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -134,16 +134,16 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString(')
                                                 parseExpression(${)
-                                                  parsePrecedenceExpression(${, 1, true)
-                                                    parseUnaryExpression(${, true)
-                                                      parsePrimary(${, expression)
+                                                  parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                      parsePrimary(${, expression, ConstantPatternContext.none)
                                                         parseSendOrFunctionLiteral(${, expression)
                                                           parseSend(${, expression)
                                                             isNextIdentifier(${)

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

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 9dc3555..557f56b 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
@@ -45,9 +45,9 @@
                       parseVariableInitializerOpt(i)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(10)
                         listener: endVariableInitializer(=)
@@ -61,9 +61,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -76,23 +76,23 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString(')
                                                 parseExpression(${)
-                                                  parsePrecedenceExpression(${, 1, true)
-                                                    parseUnaryExpression(${, true)
-                                                      parsePrimary(${, expression)
-                                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(${)
-                                                          parseParenthesizedExpressionOrRecordLiteral(${, null)
+                                                  parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                      parsePrimary(${, expression, ConstantPatternContext.none)
+                                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(${, ConstantPatternContext.none)
+                                                          parseParenthesizedExpressionOrRecordLiteral(${, null, ConstantPatternContext.none)
                                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                             parseExpression(()
-                                                              parsePrecedenceExpression((, 1, true)
-                                                                parseUnaryExpression((, true)
-                                                                  parsePrimary((, expression)
+                                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                                     parseSendOrFunctionLiteral((, expression)
                                                                       parseSend((, expression)
                                                                         isNextIdentifier(()
@@ -128,9 +128,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -143,23 +143,23 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString(')
                                                 parseExpression(${)
-                                                  parsePrecedenceExpression(${, 1, true)
-                                                    parseUnaryExpression(${, true)
-                                                      parsePrimary(${, expression)
-                                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(${)
-                                                          parseParenthesizedExpressionOrRecordLiteral(${, null)
+                                                  parsePrecedenceExpression(${, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(${, true, ConstantPatternContext.none)
+                                                      parsePrimary(${, expression, ConstantPatternContext.none)
+                                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(${, ConstantPatternContext.none)
+                                                          parseParenthesizedExpressionOrRecordLiteral(${, null, ConstantPatternContext.none)
                                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                             parseExpression(()
-                                                              parsePrecedenceExpression((, 1, true)
-                                                                parseUnaryExpression((, true)
-                                                                  parsePrimary((, expression)
+                                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                                     parseSendOrFunctionLiteral((, expression)
                                                                       parseSend((, expression)
                                                                         isNextIdentifier(()

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49132.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_49132.dart.intertwined.expect
index 011740f..5051fed 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49132.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49132.dart.intertwined.expect
@@ -80,9 +80,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -92,9 +92,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -119,9 +119,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -131,9 +131,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -218,9 +218,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -230,9 +230,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -257,9 +257,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -269,9 +269,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -356,9 +356,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -368,9 +368,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -395,9 +395,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -407,9 +407,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -494,9 +494,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -506,9 +506,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -533,9 +533,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -545,9 +545,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -632,9 +632,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -644,9 +644,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -671,9 +671,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -683,9 +683,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -700,9 +700,9 @@
                                 computeTypeAfterIsOrAs(as)
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralSetOrMapSuffix(?, null)
                                 listener: handleIdentifier(int, typeReference)
                                 listener: handleNoTypeArguments(?)
@@ -778,9 +778,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -790,9 +790,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -817,9 +817,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -829,9 +829,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -846,9 +846,9 @@
                                 computeTypeAfterIsOrAs(is)
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralSetOrMapSuffix(?, null)
                                 listener: handleIdentifier(int, typeReference)
                                 listener: handleNoTypeArguments(?)
@@ -924,9 +924,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -936,9 +936,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -963,9 +963,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -975,9 +975,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -1064,9 +1064,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -1076,9 +1076,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -1103,9 +1103,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -1115,9 +1115,9 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49132_not_nullable.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_49132_not_nullable.dart.intertwined.expect
index cde11f0..867504d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49132_not_nullable.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49132_not_nullable.dart.intertwined.expect
@@ -85,9 +85,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -97,9 +97,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -114,14 +114,14 @@
                                 computeTypeAfterIsOrAs(is)
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralSetOrMapSuffix(?, null)
                                     parseExpressionWithoutCascade(:)
-                                      parsePrecedenceExpression(:, 1, false)
-                                        parseUnaryExpression(:, false)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralListSuffix(:, null)
                                               rewriteSquareBrackets(:)
                                                 link([, ])
@@ -135,18 +135,18 @@
                               parseConditionalExpressionRest(int)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments({)
                                         parseLiteralSetOrMapSuffix(?, null)
                                           listener: handleLiteralSetOrMap(0, {, null, }, false)
                                 ensureColon(})
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments([])
                                         parseLiteralListSuffix(:, null)
                                           rewriteSquareBrackets(:)
@@ -210,9 +210,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -222,9 +222,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -239,37 +239,37 @@
                                 computeTypeAfterIsOrAs(is)
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralSetOrMapSuffix(?, null)
                                               parseExpression({)
-                                                parsePrecedenceExpression({, 1, true)
-                                                  parseUnaryExpression({, true)
-                                                    parsePrimary({, expression)
+                                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                    parsePrimary({, expression, ConstantPatternContext.none)
                                                       parseLiteralString({)
                                                         parseSingleLiteralString({)
                                               parseExpression(:)
-                                                parsePrecedenceExpression(:, 1, true)
-                                                  parseUnaryExpression(:, true)
-                                                    parsePrimary(:, expression)
+                                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                                       parseLiteralString(:)
                                                         parseSingleLiteralString(:)
                                     parseExpressionWithoutCascade(:)
-                                      parsePrecedenceExpression(:, 1, false)
-                                        parseUnaryExpression(:, false)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralListSuffix(:, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseLiteralString([)
                                                         parseSingleLiteralString([)
                                               parseExpression(,)
-                                                parsePrecedenceExpression(,, 1, true)
-                                                  parseUnaryExpression(,, true)
-                                                    parsePrimary(,, expression)
+                                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                                       parseLiteralString(,)
                                                         parseSingleLiteralString(,)
                                 listener: handleIdentifier(int, typeReference)
@@ -281,23 +281,23 @@
                               parseConditionalExpressionRest(int)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments({)
                                         parseLiteralSetOrMapSuffix(?, null)
                                           parseExpression({)
-                                            parsePrecedenceExpression({, 1, true)
-                                              parseUnaryExpression({, true)
-                                                parsePrimary({, expression)
+                                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                parsePrimary({, expression, ConstantPatternContext.none)
                                                   parseLiteralString({)
                                                     parseSingleLiteralString({)
                                                       listener: beginLiteralString("a")
                                                       listener: endLiteralString(0, :)
                                           parseExpression(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralString(:)
                                                     parseSingleLiteralString(:)
                                                       listener: beginLiteralString("b")
@@ -307,23 +307,23 @@
                                 ensureColon(})
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments([)
                                         parseLiteralListSuffix(:, null)
                                           parseExpression([)
-                                            parsePrecedenceExpression([, 1, true)
-                                              parseUnaryExpression([, true)
-                                                parsePrimary([, expression)
+                                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                parsePrimary([, expression, ConstantPatternContext.none)
                                                   parseLiteralString([)
                                                     parseSingleLiteralString([)
                                                       listener: beginLiteralString("a")
                                                       listener: endLiteralString(0, ,)
                                           parseExpression(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralString(,)
                                                     parseSingleLiteralString(,)
                                                       listener: beginLiteralString("b")
@@ -386,9 +386,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -398,9 +398,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -415,14 +415,14 @@
                                 computeTypeAfterIsOrAs(as)
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralSetOrMapSuffix(?, null)
                                     parseExpressionWithoutCascade(:)
-                                      parsePrecedenceExpression(:, 1, false)
-                                        parseUnaryExpression(:, false)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralListSuffix(:, null)
                                               rewriteSquareBrackets(:)
                                                 link([, ])
@@ -436,18 +436,18 @@
                               parseConditionalExpressionRest(bool)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments({)
                                         parseLiteralSetOrMapSuffix(?, null)
                                           listener: handleLiteralSetOrMap(0, {, null, }, false)
                                 ensureColon(})
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments([])
                                         parseLiteralListSuffix(:, null)
                                           rewriteSquareBrackets(:)
@@ -511,9 +511,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -523,9 +523,9 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
                                       isNextIdentifier(=)
@@ -540,37 +540,37 @@
                                 computeTypeAfterIsOrAs(as)
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralSetOrMapSuffix(?, null)
                                               parseExpression({)
-                                                parsePrecedenceExpression({, 1, true)
-                                                  parseUnaryExpression({, true)
-                                                    parsePrimary({, expression)
+                                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                    parsePrimary({, expression, ConstantPatternContext.none)
                                                       parseLiteralString({)
                                                         parseSingleLiteralString({)
                                               parseExpression(:)
-                                                parsePrecedenceExpression(:, 1, true)
-                                                  parseUnaryExpression(:, true)
-                                                    parsePrimary(:, expression)
+                                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                                       parseLiteralString(:)
                                                         parseSingleLiteralString(:)
                                     parseExpressionWithoutCascade(:)
-                                      parsePrecedenceExpression(:, 1, false)
-                                        parseUnaryExpression(:, false)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralListSuffix(:, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseLiteralString([)
                                                         parseSingleLiteralString([)
                                               parseExpression(,)
-                                                parsePrecedenceExpression(,, 1, true)
-                                                  parseUnaryExpression(,, true)
-                                                    parsePrimary(,, expression)
+                                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                                       parseLiteralString(,)
                                                         parseSingleLiteralString(,)
                                 listener: handleIdentifier(bool, typeReference)
@@ -582,23 +582,23 @@
                               parseConditionalExpressionRest(bool)
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments({)
                                         parseLiteralSetOrMapSuffix(?, null)
                                           parseExpression({)
-                                            parsePrecedenceExpression({, 1, true)
-                                              parseUnaryExpression({, true)
-                                                parsePrimary({, expression)
+                                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                parsePrimary({, expression, ConstantPatternContext.none)
                                                   parseLiteralString({)
                                                     parseSingleLiteralString({)
                                                       listener: beginLiteralString("a")
                                                       listener: endLiteralString(0, :)
                                           parseExpression(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralString(:)
                                                     parseSingleLiteralString(:)
                                                       listener: beginLiteralString("b")
@@ -608,23 +608,23 @@
                                 ensureColon(})
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments([)
                                         parseLiteralListSuffix(:, null)
                                           parseExpression([)
-                                            parsePrecedenceExpression([, 1, true)
-                                              parseUnaryExpression([, true)
-                                                parsePrimary([, expression)
+                                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                parsePrimary([, expression, ConstantPatternContext.none)
                                                   parseLiteralString([)
                                                     parseSingleLiteralString([)
                                                       listener: beginLiteralString("a")
                                                       listener: endLiteralString(0, ,)
                                           parseExpression(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralString(,)
                                                     parseSingleLiteralString(,)
                                                       listener: beginLiteralString("b")

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

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 c4c2359..3b09860 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
@@ -80,9 +80,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -92,16 +92,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -128,9 +128,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -140,16 +140,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -236,9 +236,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -248,16 +248,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -284,9 +284,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -296,16 +296,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -392,9 +392,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -404,16 +404,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -440,9 +440,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -452,16 +452,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -548,9 +548,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -560,16 +560,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -596,9 +596,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -608,16 +608,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -704,9 +704,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -716,16 +716,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -752,9 +752,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -764,16 +764,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -862,9 +862,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -874,16 +874,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -910,9 +910,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -922,16 +922,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -1020,9 +1020,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -1032,16 +1032,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -1068,9 +1068,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -1080,16 +1080,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -1178,9 +1178,9 @@
                       listener: beginInitializer(x)
                       parseInitializerExpressionRest(:)
                         parseExpression(:)
-                          parsePrecedenceExpression(:, 1, true)
-                            parseUnaryExpression(:, true)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -1190,16 +1190,16 @@
                                     parseArgumentsOpt(x)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(x, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()
@@ -1226,9 +1226,9 @@
                       listener: beginInitializer(y)
                       parseInitializerExpressionRest(,)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)
@@ -1238,16 +1238,16 @@
                                     parseArgumentsOpt(y)
                                       listener: handleNoArguments(=)
                                     listener: handleSend(y, =)
-                            parsePrecedenceExpression(=, 1, true)
-                              parseUnaryExpression(=, true)
-                                parsePrimary(=, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                    parseParenthesizedExpressionOrRecordLiteral(=, null)
+                            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                       listener: beginParenthesizedExpressionOrRecordLiteral(()
                                       parseExpression(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
                                                   isNextIdentifier(()

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49678.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_49678.dart.intertwined.expect
index f41ebd6..9166c99 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49678.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49678.dart.intertwined.expect
@@ -66,21 +66,21 @@
                     parseVariableInitializerOpt(m)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(=, null)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(0)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralMapEntry(:, })
@@ -96,9 +96,9 @@
                 looksLikeLocalFunction(m)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -110,9 +110,9 @@
                               listener: handleSend(m, [)
                       parseArgumentOrIndexStar(m, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -151,15 +151,15 @@
                     parseVariableInitializerOpt(list)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(=, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           parseSend([, expression)
                                             isNextIdentifier([)
@@ -179,9 +179,9 @@
                                       listener: handleAsOperator(as)
                                       skipChainedAsIsOperators(?)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(,, expression)
                                           parseSend(,, expression)
                                             isNextIdentifier(,)
@@ -201,9 +201,9 @@
                                       listener: handleAsOperator(as)
                                       skipChainedAsIsOperators(?)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(,, expression)
                                           parseSend(,, expression)
                                             isNextIdentifier(,)
@@ -244,15 +244,15 @@
                     parseVariableInitializerOpt(list2)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(=, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           parseSend([, expression)
                                             isNextIdentifier([)
@@ -272,9 +272,9 @@
                                       listener: handleIsOperator(is, null)
                                       skipChainedAsIsOperators(?)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(,, expression)
                                           parseSend(,, expression)
                                             isNextIdentifier(,)
@@ -294,9 +294,9 @@
                                       listener: handleIsOperator(is, null)
                                       skipChainedAsIsOperators(?)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral(,, expression)
                                           parseSend(,, expression)
                                             isNextIdentifier(,)
@@ -326,15 +326,15 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(return, null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)
@@ -344,7 +344,7 @@
                                       parseArgumentsOpt(list)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(list, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -356,9 +356,9 @@
                                     listener: handleSend(first, ,)
                               listener: handleEndingBinaryExpression(.)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(,, expression)
                                     parseSend(,, expression)
                                       isNextIdentifier(,)
@@ -368,7 +368,7 @@
                                       parseArgumentsOpt(list2)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(list2, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/issue_49678_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_49678_prime.dart.intertwined.expect
index d3ed1fd..bcd0d69 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_49678_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_49678_prime.dart.intertwined.expect
@@ -66,21 +66,21 @@
                     parseVariableInitializerOpt(m)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(=, null)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(0)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralMapEntry(:, })
@@ -96,9 +96,9 @@
                 looksLikeLocalFunction(m)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -110,16 +110,16 @@
                               listener: handleSend(m, [)
                       parseArgumentOrIndexStar(m, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
-                                  parseParenthesizedExpressionOrRecordLiteral([, null)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral([, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -160,22 +160,22 @@
                     parseVariableInitializerOpt(list)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(=, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
-                                          parseParenthesizedExpressionOrRecordLiteral([, null)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral([, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -197,16 +197,16 @@
                                             ensureCloseParen(?, ()
                                             listener: endParenthesizedExpression(()
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                          parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -228,16 +228,16 @@
                                             ensureCloseParen(?, ()
                                             listener: endParenthesizedExpression(()
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                          parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -280,22 +280,22 @@
                     parseVariableInitializerOpt(list2)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(=, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
-                                          parseParenthesizedExpressionOrRecordLiteral([, null)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral([, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -317,16 +317,16 @@
                                             ensureCloseParen(?, ()
                                             listener: endParenthesizedExpression(()
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                          parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -348,16 +348,16 @@
                                             ensureCloseParen(?, ()
                                             listener: endParenthesizedExpression(()
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                          parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -389,15 +389,15 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(return, null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)
@@ -407,7 +407,7 @@
                                       parseArgumentsOpt(list)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(list, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)
@@ -419,9 +419,9 @@
                                     listener: handleSend(first, ,)
                               listener: handleEndingBinaryExpression(.)
                           parseExpression(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(,, expression)
                                     parseSend(,, expression)
                                       isNextIdentifier(,)
@@ -431,7 +431,7 @@
                                       parseArgumentsOpt(list2)
                                         listener: handleNoArguments(.)
                                       listener: handleSend(list2, .)
-                              parsePrimary(., expressionContinuation)
+                              parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
                                     isNextIdentifier(.)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect
index 69bd099..4692c47 100644
--- a/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       parseVariableInitializerOpt(foo)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseNewExpression(=)
                                   isNextIdentifier(new)
                                   listener: beginNewExpression(new)
@@ -86,9 +86,9 @@
                     parseVariableInitializerOpt(bar)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -98,7 +98,7 @@
                                   parseArgumentsOpt(foo)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(foo, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
@@ -123,9 +123,9 @@
                   looksLikeLocalFunction(late)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
@@ -150,9 +150,9 @@
                 looksLikeLocalFunction(bar)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -176,9 +176,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -195,7 +195,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
@@ -222,9 +222,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -241,7 +241,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
@@ -291,9 +291,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -306,9 +306,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("hello")
@@ -378,9 +378,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -393,9 +393,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello")
@@ -451,9 +451,9 @@
                 parseFieldInitializerOpt(late, late, null, null, null, null, null, DeclarationKind.Class, Y)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect
index 90158c8..9784f8c 100644
--- a/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       parseVariableInitializerOpt(foo)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseNewExpression(=)
                                   isNextIdentifier(new)
                                   listener: beginNewExpression(new)
@@ -86,9 +86,9 @@
                     parseVariableInitializerOpt(bar)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -98,7 +98,7 @@
                                   parseArgumentsOpt(foo)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(foo, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
@@ -123,9 +123,9 @@
                   looksLikeLocalFunction(late)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
@@ -150,9 +150,9 @@
                 looksLikeLocalFunction(bar)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -176,9 +176,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -195,7 +195,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
@@ -222,9 +222,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -241,7 +241,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
@@ -285,9 +285,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -297,9 +297,9 @@
                               parseArgumentsOpt(foo)
                                 listener: handleNoArguments(=)
                               listener: handleSend(foo, =)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)
@@ -340,9 +340,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -355,9 +355,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("hello")
@@ -427,9 +427,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -442,9 +442,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello")
@@ -500,9 +500,9 @@
                 parseFieldInitializerOpt(late, late, null, null, null, null, null, DeclarationKind.Class, Y)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect
index acdb574..928d7d8 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -45,7 +45,7 @@
                               parseArgumentsOpt(foo)
                                 listener: handleNoArguments(.)
                               listener: handleSend(foo, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -57,7 +57,7 @@
                             listener: handleSend(bar, !)
                       listener: handleEndingBinaryExpression(.)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -70,9 +70,9 @@
                       listener: handleEndingBinaryExpression(.)
                       parseArgumentOrIndexStar(baz, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 b25bd3a..b0a9972 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
@@ -34,16 +34,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -53,7 +53,7 @@
                                             parseArgumentsOpt(foo)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(foo, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -67,7 +67,7 @@
                                 ensureCloseParen(bar, ()
                                 listener: endParenthesizedExpression(()
                         listener: handleNonNullAssertExpression(!)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -80,9 +80,9 @@
                         listener: handleEndingBinaryExpression(.)
                         parseArgumentOrIndexStar(baz, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect
index 4ea9042..9ed06dc 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(obj)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -48,9 +48,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect
index dcbbaed..ca031e8 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(obj)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -48,9 +48,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -64,9 +64,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 60ec194..673dbe6 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
@@ -34,30 +34,30 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                          parseParenthesizedExpressionOrRecordLiteral((, null)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                                      parseParenthesizedExpressionOrRecordLiteral((, null)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
+                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                                      parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral((, expression)
                                                                   parseSend((, expression)
                                                                     isNextIdentifier(()
@@ -72,9 +72,9 @@
                                                         listener: endParenthesizedExpression(()
                                                 parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                                                   parseExpression([)
-                                                    parsePrecedenceExpression([, 1, true)
-                                                      parseUnaryExpression([, true)
-                                                        parsePrimary([, expression)
+                                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                        parsePrimary([, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
                                                               isNextIdentifier([)
@@ -92,9 +92,9 @@
                                 listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect
index 3cb02392..1619d08 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -45,7 +45,7 @@
                               parseArgumentsOpt(foo)
                                 listener: handleNoArguments(.)
                               listener: handleSend(foo, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -59,9 +59,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 d82b5d8..ec2e43a 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
@@ -34,16 +34,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -53,7 +53,7 @@
                                             parseArgumentsOpt(foo)
                                               listener: handleNoArguments(.)
                                             listener: handleSend(foo, .)
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -69,9 +69,9 @@
                         listener: handleNonNullAssertExpression(!)
                         parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect
index 008aad6..ddf421c 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -46,7 +46,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(foo, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -60,9 +60,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 9121ae0..2ff47d0 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
@@ -34,23 +34,23 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                          parseParenthesizedExpressionOrRecordLiteral((, null)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()
@@ -63,7 +63,7 @@
                                                 listener: handleNonNullAssertExpression(!)
                                             ensureCloseParen(!, ()
                                             listener: endParenthesizedExpression(()
-                                    parsePrimary(., expressionContinuation)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
                                           isNextIdentifier(.)
@@ -79,9 +79,9 @@
                                 listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect
index 0d4ca4e..06792f1 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -45,7 +45,7 @@
                               parseArgumentsOpt(foo)
                                 listener: handleNoArguments(.)
                               listener: handleSend(foo, .)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -59,9 +59,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -75,9 +75,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 6b2e061..57cb760 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
@@ -34,30 +34,30 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                          parseParenthesizedExpressionOrRecordLiteral((, null)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                                      parseParenthesizedExpressionOrRecordLiteral((, null)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
+                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                                      parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseSendOrFunctionLiteral((, expression)
                                                                   parseSend((, expression)
                                                                     isNextIdentifier(()
@@ -67,7 +67,7 @@
                                                                     parseArgumentsOpt(foo)
                                                                       listener: handleNoArguments(.)
                                                                     listener: handleSend(foo, .)
-                                                            parsePrimary(., expressionContinuation)
+                                                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral(., expressionContinuation)
                                                                 parseSend(., expressionContinuation)
                                                                   isNextIdentifier(.)
@@ -83,9 +83,9 @@
                                                         listener: endParenthesizedExpression(()
                                                 parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                                                   parseExpression([)
-                                                    parsePrecedenceExpression([, 1, true)
-                                                      parseUnaryExpression([, true)
-                                                        parsePrimary([, expression)
+                                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                        parsePrimary([, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
                                                               isNextIdentifier([)
@@ -103,9 +103,9 @@
                                 listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect
index 14b68ff..aec1ec5 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -46,7 +46,7 @@
                                 listener: handleNoArguments(!)
                               listener: handleSend(foo, !)
                       listener: handleNonNullAssertExpression(!)
-                      parsePrimary(., expressionContinuation)
+                      parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
                             isNextIdentifier(.)
@@ -60,9 +60,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)
@@ -76,9 +76,9 @@
                       listener: handleNonNullAssertExpression(!)
                       parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
                                     isNextIdentifier([)

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

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 082a615..9e0e5ee 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
@@ -34,37 +34,37 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                          parseParenthesizedExpressionOrRecordLiteral((, null)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
-                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                                      parseParenthesizedExpressionOrRecordLiteral((, null)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
+                                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                                      parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
-                                                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                                                  parseParenthesizedExpressionOrRecordLiteral((, null)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                                                  parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                                     parseExpression(()
-                                                                      parsePrecedenceExpression((, 1, true)
-                                                                        parseUnaryExpression((, true)
-                                                                          parsePrimary((, expression)
+                                                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                          parsePrimary((, expression, ConstantPatternContext.none)
                                                                             parseSendOrFunctionLiteral((, expression)
                                                                               parseSend((, expression)
                                                                                 isNextIdentifier(()
@@ -77,7 +77,7 @@
                                                                         listener: handleNonNullAssertExpression(!)
                                                                     ensureCloseParen(!, ()
                                                                     listener: endParenthesizedExpression(()
-                                                            parsePrimary(., expressionContinuation)
+                                                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                                               parseSendOrFunctionLiteral(., expressionContinuation)
                                                                 parseSend(., expressionContinuation)
                                                                   isNextIdentifier(.)
@@ -93,9 +93,9 @@
                                                         listener: endParenthesizedExpression(()
                                                 parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                                                   parseExpression([)
-                                                    parsePrecedenceExpression([, 1, true)
-                                                      parseUnaryExpression([, true)
-                                                        parsePrimary([, expression)
+                                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                        parsePrimary([, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
                                                               isNextIdentifier([)
@@ -113,9 +113,9 @@
                                 listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

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 26bc3e8..8278868 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
@@ -34,16 +34,16 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -58,9 +58,9 @@
                                 listener: endParenthesizedExpression(()
                         parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
                                       isNextIdentifier([)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect
index 1c93541..fb52c21 100644
--- a/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect
@@ -66,9 +66,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
                                 isNextIdentifier(=>)
@@ -193,9 +193,9 @@
                 looksLikeLocalFunction(c1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -205,13 +205,13 @@
                               parseArgumentsOpt(c1)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(c1, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(0)
                           listener: handleLiteralList(1, [, null, ])
@@ -225,9 +225,9 @@
                 looksLikeLocalFunction(c1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -237,20 +237,20 @@
                               parseArgumentsOpt(c1)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(c1, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(0)
                           listener: handleLiteralList(1, [, null, ])
                       listener: handleEndingBinaryExpression(?.)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(1)
                       listener: handleAssignmentExpression(=)
@@ -263,9 +263,9 @@
                 looksLikeLocalFunction(c1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -277,20 +277,20 @@
                               listener: handleSend(c1, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                       parseArgumentOrIndexStar(c1, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
@@ -303,9 +303,9 @@
                 looksLikeLocalFunction(c1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -317,30 +317,30 @@
                               listener: handleSend(c1, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
-                            parsePrecedenceExpression(=, 1, false)
-                              parseUnaryExpression(=, false)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(=, false, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                       parseArgumentOrIndexStar(c1, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(1)
                       listener: handleAssignmentExpression(=)
@@ -353,9 +353,9 @@
                 looksLikeLocalFunction(c1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -367,20 +367,20 @@
                               listener: handleSend(c1, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                       parseArgumentOrIndexStar(c1, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
@@ -393,9 +393,9 @@
                 looksLikeLocalFunction(c1)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -407,30 +407,30 @@
                               listener: handleSend(c1, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
-                            parsePrecedenceExpression(=, 1, false)
-                              parseUnaryExpression(=, false)
-                                parsePrimary(=, expression)
+                            parsePrecedenceExpression(=, 1, false, ConstantPatternContext.none)
+                              parseUnaryExpression(=, false, ConstantPatternContext.none)
+                                parsePrimary(=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(=)
                       parseArgumentOrIndexStar(c1, Instance of 'NoTypeParamOrArg', true)
                         parseExpression([)
-                          parsePrecedenceExpression([, 1, true)
-                            parseUnaryExpression([, true)
-                              parsePrimary([, expression)
+                          parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression([, true, ConstantPatternContext.none)
+                              parsePrimary([, expression, ConstantPatternContext.none)
                                 parseLiteralInt([)
                                   listener: handleLiteralInt(0)
                         listener: handleIndexedExpression(?, [, ])
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(1)
                       listener: handleAssignmentExpression(=)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect
index 12ff55c..ca7cb91 100644
--- a/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       parseVariableInitializerOpt(foo)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseNewExpression(=)
                                   isNextIdentifier(new)
                                   listener: beginNewExpression(new)
@@ -86,9 +86,9 @@
                     parseVariableInitializerOpt(bar)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -98,7 +98,7 @@
                                   parseArgumentsOpt(foo)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(foo, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
@@ -123,9 +123,9 @@
                   looksLikeLocalFunction(required)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
@@ -150,9 +150,9 @@
                 looksLikeLocalFunction(bar)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -176,9 +176,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -195,7 +195,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
@@ -222,9 +222,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -241,7 +241,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
@@ -291,9 +291,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -306,9 +306,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("hello")
@@ -378,9 +378,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -393,9 +393,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello")
@@ -451,9 +451,9 @@
                 parseFieldInitializerOpt(required, required, null, null, null, null, null, DeclarationKind.Class, Y)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

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

diff --git a/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect
index 6e1d94e..1db6d75 100644
--- a/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       parseVariableInitializerOpt(foo)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseNewExpression(=)
                                   isNextIdentifier(new)
                                   listener: beginNewExpression(new)
@@ -86,9 +86,9 @@
                     parseVariableInitializerOpt(bar)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -98,7 +98,7 @@
                                   parseArgumentsOpt(foo)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(foo, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
@@ -123,9 +123,9 @@
                   looksLikeLocalFunction(required)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
@@ -150,9 +150,9 @@
                 looksLikeLocalFunction(bar)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -176,9 +176,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -195,7 +195,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
@@ -222,9 +222,9 @@
                   looksLikeLocalFunction(new)
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseNewExpression(;)
                               isNextIdentifier(new)
                               listener: beginNewExpression(new)
@@ -241,7 +241,7 @@
                                   listener: beginArguments(()
                                   listener: endArguments(0, (, ))
                               listener: endNewExpression(new)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
@@ -307,9 +307,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -322,9 +322,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString("hello")
@@ -394,9 +394,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -409,9 +409,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("hello")
@@ -467,9 +467,9 @@
                 parseFieldInitializerOpt(required, required, null, null, null, null, null, DeclarationKind.Class, Y)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseLiteralInt(=)
                             listener: handleLiteralInt(42)
                   listener: endFieldInitializer(=, ;)

pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method.dart.intertwined.expect

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 4d20cfe..856b5c4 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
@@ -67,9 +67,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseThisExpression(=>, expression)
                               listener: handleThisExpression(this, expression)
                     ensureSemicolon(this)
@@ -124,9 +124,9 @@
                     parseVariableInitializerOpt(foo)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseNewExpression(=)
                                 isNextIdentifier(new)
                                 listener: beginNewExpression(new)
@@ -154,9 +154,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -170,9 +170,9 @@
                         listener: handleExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >)
                       rewriter()
                       listener: beginBinaryExpression(>>>)
-                      parsePrecedenceExpression(>>>, 13, true)
-                        parseUnaryExpression(>>>, true)
-                          parsePrimary(>>>, expression)
+                      parsePrecedenceExpression(>>>, 13, true, ConstantPatternContext.none)
+                        parseUnaryExpression(>>>, true, ConstantPatternContext.none)
+                          parsePrimary(>>>, expression, ConstantPatternContext.none)
                             parseLiteralInt(>>>)
                               listener: handleLiteralInt(42)
                       listener: endBinaryExpression(>>>)
@@ -185,9 +185,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -200,9 +200,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -216,9 +216,9 @@
                                           listener: handleExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >)
                                         rewriter()
                                         listener: beginBinaryExpression(>>>)
-                                        parsePrecedenceExpression(>>>, 13, true)
-                                          parseUnaryExpression(>>>, true)
-                                            parsePrimary(>>>, expression)
+                                        parsePrecedenceExpression(>>>, 13, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>>, true, ConstantPatternContext.none)
+                                            parsePrimary(>>>, expression, ConstantPatternContext.none)
                                               parseLiteralInt(>>>)
                                                 listener: handleLiteralInt(42)
                                         listener: endBinaryExpression(>>>)
@@ -233,9 +233,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -248,9 +248,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -263,9 +263,9 @@
                                         reportExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >=)
                                           listener: handleExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >=)
                                         rewriter()
-                                        parsePrecedenceExpression(>>>=, 1, true)
-                                          parseUnaryExpression(>>>=, true)
-                                            parsePrimary(>>>=, expression)
+                                        parsePrecedenceExpression(>>>=, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>>=, true, ConstantPatternContext.none)
+                                            parsePrimary(>>>=, expression, ConstantPatternContext.none)
                                               parseLiteralInt(>>>=)
                                                 listener: handleLiteralInt(42)
                                         listener: handleAssignmentExpression(>>>=)
@@ -281,16 +281,16 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -303,18 +303,18 @@
                                     reportExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >=)
                                       listener: handleExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >=)
                                     rewriter()
-                                    parsePrecedenceExpression(>>>=, 1, true)
-                                      parseUnaryExpression(>>>=, true)
-                                        parsePrimary(>>>=, expression)
+                                    parsePrecedenceExpression(>>>=, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(>>>=, true, ConstantPatternContext.none)
+                                        parsePrimary(>>>=, expression, ConstantPatternContext.none)
                                           parseLiteralInt(>>>=)
                                             listener: handleLiteralInt(42)
                                     listener: handleAssignmentExpression(>>>=)
                                 ensureCloseParen(42, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(==, expression)
                                 parseSend(==, expression)
                                   isNextIdentifier(==)
@@ -340,9 +340,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -355,9 +355,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString("same")

pkg/front_end/parser_testcases/no-triple-shift/define_triple_shift_method_prime.dart.intertwined.expect

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 b461254..f2bfa0d 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
@@ -64,9 +64,9 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseThisExpression(=>, expression)
                               listener: handleThisExpression(this, expression)
                     ensureSemicolon(this)
@@ -121,9 +121,9 @@
                     parseVariableInitializerOpt(foo)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseNewExpression(=)
                                 isNextIdentifier(new)
                                 listener: beginNewExpression(new)
@@ -151,9 +151,9 @@
                 looksLikeLocalFunction(foo)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -164,9 +164,9 @@
                                 listener: handleNoArguments(>>)
                               listener: handleSend(foo, >>)
                       listener: beginBinaryExpression(>>)
-                      parsePrecedenceExpression(>>, 13, true)
-                        parseUnaryExpression(>>, true)
-                          parsePrimary(>>, expression)
+                      parsePrecedenceExpression(>>, 13, true, ConstantPatternContext.none)
+                        parseUnaryExpression(>>, true, ConstantPatternContext.none)
+                          parsePrimary(>>, expression, ConstantPatternContext.none)
                             parseLiteralInt(>>)
                               listener: handleLiteralInt(42)
                       listener: endBinaryExpression(>>)
@@ -179,9 +179,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -194,9 +194,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -207,9 +207,9 @@
                                                   listener: handleNoArguments(>>)
                                                 listener: handleSend(foo, >>)
                                         listener: beginBinaryExpression(>>)
-                                        parsePrecedenceExpression(>>, 13, true)
-                                          parseUnaryExpression(>>, true)
-                                            parsePrimary(>>, expression)
+                                        parsePrecedenceExpression(>>, 13, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>, true, ConstantPatternContext.none)
+                                            parsePrimary(>>, expression, ConstantPatternContext.none)
                                               parseLiteralInt(>>)
                                                 listener: handleLiteralInt(42)
                                         listener: endBinaryExpression(>>)
@@ -224,9 +224,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -239,9 +239,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -251,9 +251,9 @@
                                                 parseArgumentsOpt(foo)
                                                   listener: handleNoArguments(>>=)
                                                 listener: handleSend(foo, >>=)
-                                        parsePrecedenceExpression(>>=, 1, true)
-                                          parseUnaryExpression(>>=, true)
-                                            parsePrimary(>>=, expression)
+                                        parsePrecedenceExpression(>>=, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>>=, true, ConstantPatternContext.none)
+                                            parsePrimary(>>=, expression, ConstantPatternContext.none)
                                               parseLiteralInt(>>=)
                                                 listener: handleLiteralInt(42)
                                         listener: handleAssignmentExpression(>>=)
@@ -269,16 +269,16 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
                                             isNextIdentifier(()
@@ -288,18 +288,18 @@
                                             parseArgumentsOpt(foo)
                                               listener: handleNoArguments(>>=)
                                             listener: handleSend(foo, >>=)
-                                    parsePrecedenceExpression(>>=, 1, true)
-                                      parseUnaryExpression(>>=, true)
-                                        parsePrimary(>>=, expression)
+                                    parsePrecedenceExpression(>>=, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(>>=, true, ConstantPatternContext.none)
+                                        parsePrimary(>>=, expression, ConstantPatternContext.none)
                                           parseLiteralInt(>>=)
                                             listener: handleLiteralInt(42)
                                     listener: handleAssignmentExpression(>>=)
                                 ensureCloseParen(42, ()
                                 listener: endParenthesizedExpression(()
                         listener: beginBinaryExpression(==)
-                        parsePrecedenceExpression(==, 8, true)
-                          parseUnaryExpression(==, true)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                          parseUnaryExpression(==, true, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(==, expression)
                                 parseSend(==, expression)
                                   isNextIdentifier(==)
@@ -325,9 +325,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -340,9 +340,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString("same")

pkg/front_end/parser_testcases/no-triple-shift/simple_attempted_usage_of_triple_shift.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/no-triple-shift/simple_attempted_usage_of_triple_shift.dart.intertwined.expect b/pkg/front_end/parser_testcases/no-triple-shift/simple_attempted_usage_of_triple_shift.dart.intertwined.expect
index cee6959..394e641 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/simple_attempted_usage_of_triple_shift.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/simple_attempted_usage_of_triple_shift.dart.intertwined.expect
@@ -58,18 +58,18 @@
                     parseVariableInitializerOpt(x)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralInt(=)
                                 listener: handleLiteralInt(10)
                           reportExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >)
                             listener: handleExperimentNotEnabled(ExperimentalFlag.tripleShift, >>, >)
                           rewriter()
                           listener: beginBinaryExpression(>>>)
-                          parsePrecedenceExpression(>>>, 13, true)
-                            parseUnaryExpression(>>>, true)
-                              parsePrimary(>>>, expression)
+                          parsePrecedenceExpression(>>>, 13, true, ConstantPatternContext.none)
+                            parseUnaryExpression(>>>, true, ConstantPatternContext.none)
+                              parsePrimary(>>>, expression, ConstantPatternContext.none)
                                 parseLiteralInt(>>>)
                                   listener: handleLiteralInt(2)
                           listener: endBinaryExpression(>>>)
@@ -84,9 +84,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -99,9 +99,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralString(()
                                               parseSingleLiteralString(()
                                                 listener: beginLiteralString('x: )

pkg/front_end/parser_testcases/no-triple-shift/triple_shift_not_triple_shift.dart.intertwined.expect

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 fc32e57..a95a51f 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
@@ -56,9 +56,9 @@
               parseFunctionBody(), false, true)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralString(=>)
                             parseSingleLiteralString(=>)
                               listener: beginLiteralString("Greater Than used")
@@ -108,9 +108,9 @@
               parseFunctionBody(), false, true)
                 parseExpressionFunctionBody(=>, false)
                   parseExpression(=>)
-                    parsePrecedenceExpression(=>, 1, true)
-                      parseUnaryExpression(=>, true)
-                        parsePrimary(=>, expression)
+                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                        parsePrimary(=>, expression, ConstantPatternContext.none)
                           parseLiteralString(=>)
                             parseSingleLiteralString(=>)
                               listener: beginLiteralString("Called")
@@ -154,9 +154,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -169,24 +169,24 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralSymbol(()
                                               listener: beginLiteralSymbol(#)
                                               listener: handleOperator(>>)
                                               listener: endLiteralSymbol(#, 1)
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
-                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>)
-                                                parseParenthesizedExpressionOrRecordLiteral(>, null)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(>, ConstantPatternContext.none)
+                                                parseParenthesizedExpressionOrRecordLiteral(>, null, ConstantPatternContext.none)
                                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(()
                                                             listener: handleLiteralInt(2)
                                                   ensureCloseParen(2, ()

pkg/front_end/parser_testcases/no-triple-shift/triple_shift_symbol.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_symbol.dart.intertwined.expect b/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_symbol.dart.intertwined.expect
index 19e9353..35d284e 100644
--- a/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_symbol.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/no-triple-shift/triple_shift_symbol.dart.intertwined.expect
@@ -33,9 +33,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -48,17 +48,17 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralSymbol(()
                                               listener: beginLiteralSymbol(#)
                                               listener: handleOperator(>>)
                                               listener: endLiteralSymbol(#, 1)
                                         listener: beginBinaryExpression(>)
-                                        parsePrecedenceExpression(>, 9, true)
-                                          parseUnaryExpression(>, true)
-                                            parsePrimary(>, expression)
+                                        parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(>, true, ConstantPatternContext.none)
+                                            parsePrimary(>, expression, ConstantPatternContext.none)
                                               parseSend(>, expression)
                                                 isNextIdentifier(>)
                                                 ensureIdentifier(>, expression)

pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect
index d3e0dcf..456584e 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 looksLikeLocalFunction(c)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -64,20 +64,20 @@
                               parseArgumentsOpt(c)
                                 listener: handleNoArguments(?.)
                               listener: handleSend(c, ?.)
-                      parsePrimary(?., expressionContinuation)
+                      parsePrimary(?., expressionContinuation, ConstantPatternContext.none)
                         listener: handleNoTypeArguments([)
                         parseLiteralListSuffix(?., null)
                           parseExpression([)
-                            parsePrecedenceExpression([, 1, true)
-                              parseUnaryExpression([, true)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                parsePrimary([, expression, ConstantPatternContext.none)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                           listener: handleLiteralList(1, [, null, ])
                       listener: handleEndingBinaryExpression(?.)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseLiteralInt(=)
                               listener: handleLiteralInt(42)
                       listener: handleAssignmentExpression(=)

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

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 23116f8..c62103b 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
@@ -66,9 +66,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -80,23 +80,23 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -105,15 +105,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -127,9 +127,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -149,9 +149,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -163,23 +163,23 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -188,15 +188,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -210,9 +210,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -232,9 +232,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -246,20 +246,20 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -269,9 +269,9 @@
                                     parseArguments(toString)
                                       parseArgumentsRest(()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -280,15 +280,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -299,7 +299,7 @@
                                                 listener: handleNoArguments(])
                                               listener: handleSend(b, ])
                                   listener: handleLiteralList(1, [, null, ])
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -317,9 +317,9 @@
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -339,9 +339,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -353,20 +353,20 @@
                               listener: handleSend(a, ?)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -376,9 +376,9 @@
                                     parseArguments(toString)
                                       parseArgumentsRest(()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -387,15 +387,15 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 listener: handleNoTypeArguments([)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -406,7 +406,7 @@
                                                 listener: handleNoArguments(])
                                               listener: handleSend(b, ])
                                   listener: handleLiteralList(1, [, null, ])
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
@@ -424,9 +424,9 @@
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
                                     isNextIdentifier(:)
@@ -446,9 +446,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -461,9 +461,9 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(?, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(dynamic, typeReference)
@@ -472,9 +472,9 @@
                                   listener: endTypeArguments(1, <, >)
                                   parseLiteralListSuffix(>, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
                                                 isNextIdentifier([)
@@ -488,9 +488,9 @@
                         ensureColon(])
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseLiteralListSetMapOrFunction(:, null)
                                   listener: beginTypeArguments(<)
                                   listener: handleIdentifier(dynamic, typeReference)
@@ -499,9 +499,9 @@
                                   listener: endTypeArguments(1, <, >)
                                   parseLiteralListSuffix(>, null)
                                     parseExpression([)
-                                      parsePrecedenceExpression([, 1, true)
-                                        parseUnaryExpression([, true)
-                                          parsePrimary([, expression)
+                                      parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression([, true, ConstantPatternContext.none)
+                                          parsePrimary([, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
                                                 isNextIdentifier([)
@@ -522,9 +522,9 @@
                 looksLikeLocalFunction(a)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -537,22 +537,22 @@
                       parseConditionalExpressionRest(a)
                         listener: beginConditionalExpression(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?)
-                                  parseParenthesizedExpressionOrRecordLiteral(?, null)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(?, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(?, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             listener: handleNoTypeArguments([)
                                             parseLiteralListSuffix((, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
                                                           isNextIdentifier([)
@@ -568,22 +568,22 @@
                         ensureColon())
                         listener: handleConditionalExpressionColon()
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                  parseParenthesizedExpressionOrRecordLiteral(:, null)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             listener: handleNoTypeArguments([)
                                             parseLiteralListSuffix((, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
                                                           isNextIdentifier([)

pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect
index 1d255ea..2ce7480 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect
@@ -58,9 +58,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
                             isNextIdentifier(return)
@@ -72,14 +72,14 @@
                             listener: handleSend(a, ?)
                     canParseAsConditional(?)
                       parseExpressionWithoutCascade(?)
-                        parsePrecedenceExpression(?, 1, false)
-                          parseUnaryExpression(?, false)
-                            parsePrimary(?, expression)
+                        parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(?, false, ConstantPatternContext.none)
+                            parsePrimary(?, expression, ConstantPatternContext.none)
                               parseLiteralListSuffix(?, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
@@ -89,30 +89,30 @@
                                               parseArguments(b)
                                                 parseArgumentsRest(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralListSuffix((, null)
                                                             rewriteSquareBrackets(()
                                                               link([, ])
                                                               rewriter()
                       parseExpressionWithoutCascade(:)
-                        parsePrecedenceExpression(:, 1, false)
-                          parseUnaryExpression(:, false)
-                            parsePrimary(:, expression)
+                        parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(:, false, ConstantPatternContext.none)
+                            parsePrimary(:, expression, ConstantPatternContext.none)
                               parseLiteralNull(:)
                     parseConditionalExpressionRest(a)
                       listener: beginConditionalExpression(?)
                       parseExpressionWithoutCascade(?)
-                        parsePrecedenceExpression(?, 1, false)
-                          parseUnaryExpression(?, false)
-                            parsePrimary(?, expression)
+                        parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(?, false, ConstantPatternContext.none)
+                            parsePrimary(?, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(?, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
@@ -125,9 +125,9 @@
                                                 parseArgumentsRest(()
                                                   listener: beginArguments(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           listener: handleNoTypeArguments([])
                                                           parseLiteralListSuffix((, null)
                                                             rewriteSquareBrackets(()
@@ -140,9 +140,9 @@
                       ensureColon(])
                       listener: handleConditionalExpressionColon()
                       parseExpressionWithoutCascade(:)
-                        parsePrecedenceExpression(:, 1, false)
-                          parseUnaryExpression(:, false)
-                            parsePrimary(:, expression)
+                        parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(:, false, ConstantPatternContext.none)
+                            parsePrimary(:, expression, ConstantPatternContext.none)
                               parseLiteralNull(:)
                                 listener: handleLiteralNull(null)
                       listener: endConditionalExpression(?, :)

pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect
index 2759336..509ab67 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect
@@ -51,9 +51,9 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
                             isNextIdentifier(return)
@@ -64,30 +64,30 @@
                               listener: handleNoArguments(!=)
                             listener: handleSend(a, !=)
                     listener: beginBinaryExpression(!=)
-                    parsePrecedenceExpression(!=, 8, true)
-                      parseUnaryExpression(!=, true)
-                        parsePrimary(!=, expression)
+                    parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                      parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                        parsePrimary(!=, expression, ConstantPatternContext.none)
                           parseLiteralNull(!=)
                             listener: handleLiteralNull(null)
                       canParseAsConditional(?)
                         parseExpressionWithoutCascade(?)
-                          parsePrecedenceExpression(?, 1, false)
-                            parseUnaryExpression(?, false)
-                              parsePrimary(?, expression)
+                          parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(?, false, ConstantPatternContext.none)
+                              parsePrimary(?, expression, ConstantPatternContext.none)
                                 parseLiteralListSuffix(?, null)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(a)
                         parseExpressionWithoutCascade(:)
-                          parsePrecedenceExpression(:, 1, false)
-                            parseUnaryExpression(:, false)
-                              parsePrimary(:, expression)
+                          parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                            parseUnaryExpression(:, false, ConstantPatternContext.none)
+                              parsePrimary(:, expression, ConstantPatternContext.none)
                                 parseConstExpression(:)
                                   parseLiteralListSuffix(const, const)
                                     rewriteSquareBrackets(const)
@@ -96,23 +96,23 @@
                     listener: endBinaryExpression(!=)
                     canParseAsConditional(?)
                       parseExpressionWithoutCascade(?)
-                        parsePrecedenceExpression(?, 1, false)
-                          parseUnaryExpression(?, false)
-                            parsePrimary(?, expression)
+                        parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(?, false, ConstantPatternContext.none)
+                            parsePrimary(?, expression, ConstantPatternContext.none)
                               parseLiteralListSuffix(?, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           parseSend([, expression)
                                             isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                             parseArgumentsOpt(a)
                       parseExpressionWithoutCascade(:)
-                        parsePrecedenceExpression(:, 1, false)
-                          parseUnaryExpression(:, false)
-                            parsePrimary(:, expression)
+                        parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(:, false, ConstantPatternContext.none)
+                            parsePrimary(:, expression, ConstantPatternContext.none)
                               parseConstExpression(:)
                                 parseLiteralListSuffix(const, const)
                                   rewriteSquareBrackets(const)
@@ -121,15 +121,15 @@
                     parseConditionalExpressionRest(null)
                       listener: beginConditionalExpression(?)
                       parseExpressionWithoutCascade(?)
-                        parsePrecedenceExpression(?, 1, false)
-                          parseUnaryExpression(?, false)
-                            parsePrimary(?, expression)
+                        parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(?, false, ConstantPatternContext.none)
+                            parsePrimary(?, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(?, null)
                                 parseExpression([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral([, expression)
                                           parseSend([, expression)
                                             isNextIdentifier([)
@@ -143,9 +143,9 @@
                       ensureColon(])
                       listener: handleConditionalExpressionColon()
                       parseExpressionWithoutCascade(:)
-                        parsePrecedenceExpression(:, 1, false)
-                          parseUnaryExpression(:, false)
-                            parsePrimary(:, expression)
+                        parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                          parseUnaryExpression(:, false, ConstantPatternContext.none)
+                            parsePrimary(:, expression, ConstantPatternContext.none)
                               parseConstExpression(:)
                                 listener: beginConstLiteral([])
                                 listener: handleNoTypeArguments([])

pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect
index 1f44de0..34e49fb 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect
@@ -56,9 +56,9 @@
         parseFunctionBody(f, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
                         isNextIdentifier(=>)
@@ -80,11 +80,11 @@
                         parseArgumentsRest(()
                           listener: beginArguments(()
                           parseExpression(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrecedenceExpression(!, 16, true)
-                                  parseUnaryExpression(!, true)
-                                    parsePrimary(!, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrecedenceExpression(!, 16, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(!, true, ConstantPatternContext.none)
+                                    parsePrimary(!, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral(!, expression)
                                         parseSend(!, expression)
                                           isNextIdentifier(!)
@@ -96,9 +96,9 @@
                                           listener: handleSend(b, &&)
                                 listener: handleUnaryPrefixExpression(!)
                               listener: beginBinaryExpression(&&)
-                              parsePrecedenceExpression(&&, 7, true)
-                                parseUnaryExpression(&&, true)
-                                  parsePrimary(&&, expression)
+                              parsePrecedenceExpression(&&, 7, true, ConstantPatternContext.none)
+                                parseUnaryExpression(&&, true, ConstantPatternContext.none)
+                                  parsePrimary(&&, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(&&, expression)
                                       parseSend(&&, expression)
                                         isNextIdentifier(&&)
@@ -110,9 +110,9 @@
                                         listener: handleSend(c, [)
                                 parseArgumentOrIndexStar(c, Instance of 'NoTypeParamOrArg', false)
                                   parseExpression([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
                                               isNextIdentifier([)
@@ -125,23 +125,23 @@
                                   listener: handleIndexedExpression(null, [, ])
                                   canParseAsConditional(?)
                                     parseExpressionWithoutCascade(?)
-                                      parsePrecedenceExpression(?, 1, false)
-                                        parseUnaryExpression(?, false)
-                                          parsePrimary(?, expression)
+                                      parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                          parsePrimary(?, expression, ConstantPatternContext.none)
                                             parseLiteralListSuffix(?, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
                                                           isNextIdentifier([)
                                                           ensureIdentifier([, expression)
                                                           parseArgumentsOpt(a)
                                               parseExpression(,)
-                                                parsePrecedenceExpression(,, 1, true)
-                                                  parseUnaryExpression(,, true)
-                                                    parsePrimary(,, expression)
+                                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral(,, expression)
                                                         looksLikeFunctionBody(])
                                                         parseSend(,, expression)
@@ -151,23 +151,23 @@
                                                             parseArguments(e)
                                                               parseArgumentsRest(()
                                                                 parseExpression(()
-                                                                  parsePrecedenceExpression((, 1, true)
-                                                                    parseUnaryExpression((, true)
-                                                                      parsePrimary((, expression)
+                                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                                         parseSendOrFunctionLiteral((, expression)
                                                                           parseSend((, expression)
                                                                             isNextIdentifier(()
                                                                             ensureIdentifier((, expression)
                                                                             parseArgumentsOpt(f)
                                     parseExpressionWithoutCascade(:)
-                                      parsePrecedenceExpression(:, 1, false)
-                                        parseUnaryExpression(:, false)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralListSuffix(:, null)
                                               parseExpression([)
-                                                parsePrecedenceExpression([, 1, true)
-                                                  parseUnaryExpression([, true)
-                                                    parsePrimary([, expression)
+                                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                    parsePrimary([, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
                                                           isNextIdentifier([)
@@ -175,23 +175,23 @@
                                                           parseArgumentsOpt(a)
                                 canParseAsConditional(?)
                                   parseExpressionWithoutCascade(?)
-                                    parsePrecedenceExpression(?, 1, false)
-                                      parseUnaryExpression(?, false)
-                                        parsePrimary(?, expression)
+                                    parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                        parsePrimary(?, expression, ConstantPatternContext.none)
                                           parseLiteralListSuffix(?, null)
                                             parseExpression([)
-                                              parsePrecedenceExpression([, 1, true)
-                                                parseUnaryExpression([, true)
-                                                  parsePrimary([, expression)
+                                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                  parsePrimary([, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral([, expression)
                                                       parseSend([, expression)
                                                         isNextIdentifier([)
                                                         ensureIdentifier([, expression)
                                                         parseArgumentsOpt(a)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       looksLikeFunctionBody(])
                                                       parseSend(,, expression)
@@ -201,23 +201,23 @@
                                                           parseArguments(e)
                                                             parseArgumentsRest(()
                                                               parseExpression(()
-                                                                parsePrecedenceExpression((, 1, true)
-                                                                  parseUnaryExpression((, true)
-                                                                    parsePrimary((, expression)
+                                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                                       parseSendOrFunctionLiteral((, expression)
                                                                         parseSend((, expression)
                                                                           isNextIdentifier(()
                                                                           ensureIdentifier((, expression)
                                                                           parseArgumentsOpt(f)
                                   parseExpressionWithoutCascade(:)
-                                    parsePrecedenceExpression(:, 1, false)
-                                      parseUnaryExpression(:, false)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralListSuffix(:, null)
                                             parseExpression([)
-                                              parsePrecedenceExpression([, 1, true)
-                                                parseUnaryExpression([, true)
-                                                  parsePrimary([, expression)
+                                              parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                  parsePrimary([, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral([, expression)
                                                       parseSend([, expression)
                                                         isNextIdentifier([)
@@ -226,23 +226,23 @@
                               listener: endBinaryExpression(&&)
                               canParseAsConditional(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         parseLiteralListSuffix(?, null)
                                           parseExpression([)
-                                            parsePrecedenceExpression([, 1, true)
-                                              parseUnaryExpression([, true)
-                                                parsePrimary([, expression)
+                                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                parsePrimary([, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
                                                       isNextIdentifier([)
                                                       ensureIdentifier([, expression)
                                                       parseArgumentsOpt(a)
                                           parseExpression(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(,, expression)
                                                     looksLikeFunctionBody(])
                                                     parseSend(,, expression)
@@ -252,23 +252,23 @@
                                                         parseArguments(e)
                                                           parseArgumentsRest(()
                                                             parseExpression(()
-                                                              parsePrecedenceExpression((, 1, true)
-                                                                parseUnaryExpression((, true)
-                                                                  parsePrimary((, expression)
+                                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                                     parseSendOrFunctionLiteral((, expression)
                                                                       parseSend((, expression)
                                                                         isNextIdentifier(()
                                                                         ensureIdentifier((, expression)
                                                                         parseArgumentsOpt(f)
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralListSuffix(:, null)
                                           parseExpression([)
-                                            parsePrecedenceExpression([, 1, true)
-                                              parseUnaryExpression([, true)
-                                                parsePrimary([, expression)
+                                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                parsePrimary([, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
                                                       isNextIdentifier([)
@@ -277,15 +277,15 @@
                               parseConditionalExpressionRest(])
                                 listener: beginConditionalExpression(?)
                                 parseExpressionWithoutCascade(?)
-                                  parsePrecedenceExpression(?, 1, false)
-                                    parseUnaryExpression(?, false)
-                                      parsePrimary(?, expression)
+                                  parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                      parsePrimary(?, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments([)
                                         parseLiteralListSuffix(?, null)
                                           parseExpression([)
-                                            parsePrecedenceExpression([, 1, true)
-                                              parseUnaryExpression([, true)
-                                                parsePrimary([, expression)
+                                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                parsePrimary([, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
                                                       isNextIdentifier([)
@@ -296,9 +296,9 @@
                                                         listener: handleNoArguments(,)
                                                       listener: handleSend(a, ,)
                                           parseExpression(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral(,, expression)
                                                     looksLikeFunctionBody(])
                                                     parseSend(,, expression)
@@ -311,9 +311,9 @@
                                                           parseArgumentsRest(()
                                                             listener: beginArguments(()
                                                             parseExpression(()
-                                                              parsePrecedenceExpression((, 1, true)
-                                                                parseUnaryExpression((, true)
-                                                                  parsePrimary((, expression)
+                                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                                     parseSendOrFunctionLiteral((, expression)
                                                                       parseSend((, expression)
                                                                         isNextIdentifier(()
@@ -329,15 +329,15 @@
                                 ensureColon(])
                                 listener: handleConditionalExpressionColon()
                                 parseExpressionWithoutCascade(:)
-                                  parsePrecedenceExpression(:, 1, false)
-                                    parseUnaryExpression(:, false)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         listener: handleNoTypeArguments([)
                                         parseLiteralListSuffix(:, null)
                                           parseExpression([)
-                                            parsePrecedenceExpression([, 1, true)
-                                              parseUnaryExpression([, true)
-                                                parsePrimary([, expression)
+                                            parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression([, true, ConstantPatternContext.none)
+                                                parsePrimary([, expression, ConstantPatternContext.none)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
                                                       isNextIdentifier([)

pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect
index 6d4a013..45fd780 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 parseFunctionBody(g, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                     ensureSemicolon(1)
@@ -116,9 +116,9 @@
                 parseFunctionBody(g, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(2)
                     ensureSemicolon(2)
@@ -169,9 +169,9 @@
                 parseFieldInitializerOpt(l, l, null, null, null, null, null, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -204,9 +204,9 @@
                 parseFieldInitializerOpt(r, r, null, null, null, null, null, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)

pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect
index b30bcda..2ab46b9 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect
@@ -52,9 +52,9 @@
                 parseFunctionBody(g, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(1)
                     ensureSemicolon(1)
@@ -116,9 +116,9 @@
                 parseFunctionBody(g, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
                             parseLiteralInt(=>)
                               listener: handleLiteralInt(2)
                     ensureSemicolon(2)
@@ -169,9 +169,9 @@
                 parseFieldInitializerOpt(l, l, null, null, null, null, null, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
@@ -204,9 +204,9 @@
                 parseFieldInitializerOpt(r, r, null, null, null, null, null, DeclarationKind.Class, C)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)

pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect
index ee1bea2..9e15a0a 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect
@@ -308,9 +308,9 @@
                 looksLikeLocalFunction(late)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)

pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect
index d2745b2..779e5f8 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect
@@ -50,9 +50,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -65,9 +65,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -131,9 +131,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -146,9 +146,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -214,9 +214,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement({)
                   parseExpression({)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
@@ -229,9 +229,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -324,9 +324,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -339,9 +339,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
                                                         isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/boolean_literal_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_case.dart.intertwined.expect
index c96c664..54e30df 100644
--- a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralBool(case)
                               listener: handleLiteralBool(true)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/boolean_literal_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_cast.dart.intertwined.expect
index a035946..33cbb27 100644
--- a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralBool(case)
                               listener: handleLiteralBool(true)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/boolean_literal_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_if_case.dart.intertwined.expect
index 2f30653..43ba717 100644
--- a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralBool(case)
                                 listener: handleLiteralBool(true)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_assert.dart.intertwined.expect
index b7904af..323f44d 100644
--- a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralBool(case)
                               listener: handleLiteralBool(true)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_check.dart.intertwined.expect
index 50ef225..1281ade 100644
--- a/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/boolean_literal_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralBool(case)
                               listener: handleLiteralBool(true)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.intertwined.expect
index 37eb8dc..786cae1 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -61,9 +61,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(case)
                                 listener: handleLiteralInt(0)
                         listener: endConstantPattern(null)
@@ -71,9 +71,9 @@
                     parseExpression(when)
                       looksLikeOuterPatternEquals(when)
                         skipOuterPattern(when)
-                      parsePrecedenceExpression(when, 1, true)
-                        parseUnaryExpression(when, true)
-                          parsePrimary(when, expression)
+                      parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(when, true, ConstantPatternContext.none)
+                          parsePrimary(when, expression, ConstantPatternContext.none)
                             parseLiteralBool(when)
                               listener: handleLiteralBool(true)
                     listener: endPatternGuard(when)

pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.intertwined.expect
index 8155c2b..91c8da9 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideSwitchStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -69,9 +69,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(0)
                       listener: endConstantPattern(null)
@@ -79,9 +79,9 @@
                   parseExpression(when)
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseLiteralBool(when)
                             listener: handleLiteralBool(true)
                   listener: endSwitchCaseWhenClause(true)

pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideIfStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideIfStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideIfStatement.dart.intertwined.expect
index fb2a243..1f8f5a4 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideIfStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideIfStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -61,9 +61,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(case)
                                 listener: handleLiteralInt(0)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideSwitchStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideSwitchStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideSwitchStatement.dart.intertwined.expect
index 60026b0..66d872a 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideSwitchStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_unguarded_insideSwitchStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -69,9 +69,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(0)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.intertwined.expect
index 93be2b1..a67a9d5 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -61,9 +61,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(case)
                                 listener: handleLiteralInt(0)
                         listener: endConstantPattern(null)
@@ -78,9 +78,9 @@
                     parseExpression(when)
                       looksLikeOuterPatternEquals(when)
                         skipOuterPattern(when)
-                      parsePrecedenceExpression(when, 1, true)
-                        parseUnaryExpression(when, true)
-                          parsePrimary(when, expression)
+                      parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(when, true, ConstantPatternContext.none)
+                          parsePrimary(when, expression, ConstantPatternContext.none)
                             parseLiteralBool(when)
                               listener: handleLiteralBool(true)
                     listener: endPatternGuard(when)

pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.intertwined.expect
index 60733e7..f6c4c2c 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideSwitchStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -69,9 +69,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(0)
                       listener: endConstantPattern(null)
@@ -86,9 +86,9 @@
                   parseExpression(when)
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseLiteralBool(when)
                             listener: handleLiteralBool(true)
                   listener: endSwitchCaseWhenClause(true)

pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideIfStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideIfStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideIfStatement.dart.intertwined.expect
index 086e3d3..5df9f48 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideIfStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideIfStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -61,9 +61,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(case)
                                 listener: handleLiteralInt(0)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideSwitchStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideSwitchStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideSwitchStatement.dart.intertwined.expect
index b3ba451..f2a46b6 100644
--- a/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideSwitchStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_unguarded_insideSwitchStatement.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -69,9 +69,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(0)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_case.dart.intertwined.expect
index 507ea9e..7ba5b7c 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_case.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern.dart.intertwined.expect
index df368f4..6e9257a 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -122,9 +122,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
index 358dadd..35657f1 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/cast_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_if_case.dart.intertwined.expect
index f5a033d..e6157c7 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/cast_inside_list_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_list_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_list_pattern.dart.intertwined.expect
index d0f4606..ad6b00e 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_list_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_list_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_lhs.dart.intertwined.expect
index 2381aba..5385a9f 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_rhs.dart.intertwined.expect
index 2291230..0df5f46 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_and_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_lhs.dart.intertwined.expect
index 211841d..4e4f0a0 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_rhs.dart.intertwined.expect
index 327585f..878ba7d 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_logical_or_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/cast_inside_map_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_map_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_map_pattern.dart.intertwined.expect
index 0dde8ad..14c0ab7 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_map_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_map_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_parenthesized_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_parenthesized_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_parenthesized_pattern.dart.intertwined.expect
index 87040e12..3a2fbee 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_parenthesized_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_parenthesized_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.intertwined.expect
index a53811e..84a36d0 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_implicitly_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -89,9 +89,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_named.dart.intertwined.expect
index c21a1dd..57c7ae0 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -77,9 +77,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -94,9 +94,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_unnamed.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_unnamed.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_unnamed.dart.intertwined.expect
index 1f03e92..9c32dad 100644
--- a/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_unnamed.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/cast_inside_record_pattern_unnamed.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -92,9 +92,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/const_patterns.dart

diff --git a/pkg/front_end/parser_testcases/patterns/const_patterns.dart b/pkg/front_end/parser_testcases/patterns/const_patterns.dart
new file mode 100644
index 0000000..b6ef3fa
--- /dev/null
+++ b/pkg/front_end/parser_testcases/patterns/const_patterns.dart
@@ -0,0 +1,93 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'const_patterns.dart' as prefix;
+
+const int value = 42;
+
+void func() {}
+
+class Class {
+  const Class([a]);
+
+  call() {}
+
+  test(o) async {
+    const dynamic local = 0;
+    dynamic variable = 0;
+    switch (o) {
+      case true: // Ok
+      case null: // Ok
+      case this: // Error
+      case this(): // Error
+      case super(): // Error
+      case 42: // Ok
+      case -42: // Ok
+      case 42.5: // Ok
+      case -42.5: // Ok
+      case 'foo': // Ok
+      case 'foo' 'bar': // Ok
+      case value: // Ok
+      case -value: // Error
+      case local: // Ok
+      case -local: // Error
+      case func: // Ok
+      case prefix.value: // Ok
+      case -prefix.value: // Error
+      case 1 + 2: // Error
+      case 1 * 2: // Error
+      case void fun() {}: // Error
+      case assert(false): // Error
+      case switch (o) { _ => true }: // Error
+      case await 0: // Error
+      case !false: // Error
+      case ~0: // Error
+      case ++variable: // Error
+      case const Class(): // Ok
+      case const Class(0): // Ok
+      case const GenericClass(): // Ok
+      case const GenericClass(a: 0): // Ok
+      case const GenericClass<int>(): // Ok
+      case const GenericClass<int>(a: 0): // Ok
+      case const GenericClass<int>.new(): // Ok
+      case const GenericClass<int>.new(a: 1): // Ok
+      case const []: // Ok
+      case const <int>[]: // Ok
+      case const {}: // Ok
+      case const <int, String>{}: // Ok
+      case const const Class(): // Error
+      case const const Class(0): // Error
+      case const const GenericClass(): // Error
+      case const const GenericClass(a: 0): // Error
+      case const const GenericClass<int>(): // Error
+      case const const GenericClass<int>(a: 0): // Error
+      case const const []: // Error
+      case const const <int>[]: // Error
+      case const const {}: // Error
+      case const const <int, String>{}: // Error
+      case const new Class(): // Error
+      case new Class(): // Error
+      case const (): // Error
+      case const const (): // Error
+      case const (1): // Ok
+      case const (-1): // Ok
+      case const (value): // Ok
+      case const (-value): // Ok
+      case const (1 + 2): // Ok
+      case GenericClass<int>: // Error
+      case prefix.GenericClass<int>: // Error
+      case GenericClass<int>.new: // Error
+      case prefix.GenericClass<int>.new: // Error
+      case const (GenericClass<int>): // Ok
+      case const (prefix.GenericClass<int>): // Ok
+      case const (GenericClass<int>.new): // Ok
+      case const (prefix.GenericClass<int>.new): // Ok
+       print(0);
+    }
+  }
+}
+
+class GenericClass<T> {
+  const GenericClass({a});
+}

pkg/front_end/parser_testcases/patterns/const_patterns.dart.expect

diff --git a/pkg/front_end/parser_testcases/patterns/const_patterns.dart.expect b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.expect
new file mode 100644
index 0000000..afb3048
--- /dev/null
+++ b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.expect
@@ -0,0 +1,1253 @@
+Problems reported:
+
+parser/patterns/const_patterns:32:13: Only negation of a numeric literal is supported as a constant pattern.
+      case -value: // Error
+            ^^^^^
+
+parser/patterns/const_patterns:34:13: Only negation of a numeric literal is supported as a constant pattern.
+      case -local: // Error
+            ^^^^^
+
+parser/patterns/const_patterns:37:13: Only negation of a numeric literal is supported as a constant pattern.
+      case -prefix.value: // Error
+            ^^^^^^
+
+parser/patterns/const_patterns:38:14: Expected ':' before this.
+      case 1 + 2: // Error
+             ^
+
+parser/patterns/const_patterns:38:14: '+' is not a prefix operator.
+      case 1 + 2: // Error
+             ^
+
+parser/patterns/const_patterns:38:16: Expected ';' after this.
+      case 1 + 2: // Error
+               ^
+
+parser/patterns/const_patterns:38:17: Expected an identifier, but got ':'.
+      case 1 + 2: // Error
+                ^
+
+parser/patterns/const_patterns:38:16: Expected ';' after this.
+      case 1 + 2: // Error
+               ^
+
+parser/patterns/const_patterns:38:17: Unexpected token ':'.
+      case 1 + 2: // Error
+                ^
+
+parser/patterns/const_patterns:39:14: Expected ':' before this.
+      case 1 * 2: // Error
+             ^
+
+parser/patterns/const_patterns:39:14: Expected an identifier, but got '*'.
+      case 1 * 2: // Error
+             ^
+
+parser/patterns/const_patterns:39:16: Expected ';' after this.
+      case 1 * 2: // Error
+               ^
+
+parser/patterns/const_patterns:39:17: Expected an identifier, but got ':'.
+      case 1 * 2: // Error
+                ^
+
+parser/patterns/const_patterns:39:16: Expected ';' after this.
+      case 1 * 2: // Error
+               ^
+
+parser/patterns/const_patterns:39:17: Unexpected token ':'.
+      case 1 * 2: // Error
+                ^
+
+parser/patterns/const_patterns:40:20: Expected ':' before this.
+      case void fun() {}: // Error
+                   ^
+
+parser/patterns/const_patterns:40:24: Expected ';' after this.
+      case void fun() {}: // Error
+                       ^
+
+parser/patterns/const_patterns:40:25: Expected an identifier, but got ':'.
+      case void fun() {}: // Error
+                        ^
+
+parser/patterns/const_patterns:40:24: Expected ';' after this.
+      case void fun() {}: // Error
+                       ^
+
+parser/patterns/const_patterns:40:25: Unexpected token ':'.
+      case void fun() {}: // Error
+                        ^
+
+parser/patterns/const_patterns:41:12: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^
+
+parser/patterns/const_patterns:44:12: The unary operator ! is not supported as a constant pattern.
+      case !false: // Error
+           ^
+
+parser/patterns/const_patterns:45:12: The unary operator ~ is not supported as a constant pattern.
+      case ~0: // Error
+           ^
+
+parser/patterns/const_patterns:59:18: Duplicate 'const' keyword in constant expression.
+      case const const Class(): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:60:18: Duplicate 'const' keyword in constant expression.
+      case const const Class(0): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:61:18: Duplicate 'const' keyword in constant expression.
+      case const const GenericClass(): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:62:18: Duplicate 'const' keyword in constant expression.
+      case const const GenericClass(a: 0): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:63:18: Duplicate 'const' keyword in constant expression.
+      case const const GenericClass<int>(): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:64:18: Duplicate 'const' keyword in constant expression.
+      case const const GenericClass<int>(a: 0): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:65:18: Duplicate 'const' keyword in constant expression.
+      case const const []: // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:66:18: Duplicate 'const' keyword in constant expression.
+      case const const <int>[]: // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:67:18: Duplicate 'const' keyword in constant expression.
+      case const const {}: // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:68:18: Duplicate 'const' keyword in constant expression.
+      case const const <int, String>{}: // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:71:19: The empty record literal is not supported as a constant pattern.
+      case const (): // Error
+                  ^
+
+parser/patterns/const_patterns:72:18: Duplicate 'const' keyword in constant expression.
+      case const const (): // Error
+                 ^^^^^
+
+parser/patterns/const_patterns:78:24: This expression is not supported as a constant pattern.
+      case GenericClass<int>: // Error
+                       ^
+
+parser/patterns/const_patterns:79:31: This expression is not supported as a constant pattern.
+      case prefix.GenericClass<int>: // Error
+                              ^
+
+parser/patterns/const_patterns:80:24: This expression is not supported as a constant pattern.
+      case GenericClass<int>.new: // Error
+                       ^
+
+parser/patterns/const_patterns:81:31: This expression is not supported as a constant pattern.
+      case prefix.GenericClass<int>.new: // Error
+                              ^
+
+beginCompilationUnit(import)
+  beginMetadataStar(import)
+  endMetadataStar(0)
+  beginUncategorizedTopLevelDeclaration(import)
+    beginImport(import)
+      beginLiteralString('const_patterns.dart')
+      endLiteralString(0, as)
+      beginConditionalUris(as)
+      endConditionalUris(0)
+      handleIdentifier(prefix, importPrefixDeclaration)
+      handleImportPrefix(null, as)
+      beginCombinators(;)
+      endCombinators(0)
+    endImport(import, null, ;)
+  endTopLevelDeclaration(const)
+  beginMetadataStar(const)
+  endMetadataStar(0)
+  beginTopLevelMember(const)
+    beginFields(DeclarationKind.TopLevel, null, null, null, null, null, null, const, ;)
+      handleIdentifier(int, typeReference)
+      handleNoTypeArguments(value)
+      handleType(int, null)
+      handleIdentifier(value, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleLiteralInt(42)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, const, 1, const, ;)
+  endTopLevelDeclaration(void)
+  beginMetadataStar(void)
+  endMetadataStar(0)
+  beginTopLevelMember(void)
+    beginTopLevelMethod(;, null, null)
+      handleVoidKeyword(void)
+      handleIdentifier(func, topLevelFunctionDeclaration)
+      handleNoTypeVariables(()
+      beginFormalParameters((, MemberKind.TopLevelMethod)
+      endFormalParameters(0, (, ), MemberKind.TopLevelMethod)
+      handleAsyncModifier(null, null)
+      beginBlockFunctionBody({)
+      endBlockFunctionBody(0, {, })
+    endTopLevelMethod(void, null, })
+  endTopLevelDeclaration(class)
+  beginMetadataStar(class)
+  endMetadataStar(0)
+  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
+    handleIdentifier(Class, classOrMixinDeclaration)
+    handleNoTypeVariables({)
+    beginClassDeclaration(class, null, null, null, null, null, null, null, null, null, Class)
+      handleNoType(Class)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleImplements(null, 0)
+      handleClassHeader(class, class, null)
+      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
+        beginMetadataStar(const)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(DeclarationKind.Class, null, null, null, null, const, null, Class)
+            handleNoType(const)
+            handleIdentifier(Class, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginOptionalFormalParameters([)
+                beginMetadataStar(a)
+                endMetadataStar(0)
+                beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
+                  handleNoType([)
+                  handleIdentifier(a, formalParameterDeclaration)
+                  handleFormalParameterWithoutValue(])
+                endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalPositional, MemberKind.NonStaticMethod)
+              endOptionalFormalParameters(1, [, ])
+            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleEmptyFunctionBody(;)
+          endClassConstructor(null, const, (, null, ;)
+        endMember()
+        beginMetadataStar(call)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, call)
+            handleNoType(;)
+            handleIdentifier(call, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+            endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            beginBlockFunctionBody({)
+            endBlockFunctionBody(0, {, })
+          endClassMethod(null, call, (, null, })
+        endMember()
+        beginMetadataStar(test)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(DeclarationKind.Class, null, null, null, null, null, null, test)
+            handleNoType(})
+            handleIdentifier(test, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginMetadataStar(o)
+              endMetadataStar(0)
+              beginFormalParameter(o, MemberKind.NonStaticMethod, null, null, null)
+                handleNoType(()
+                handleIdentifier(o, formalParameterDeclaration)
+                handleFormalParameterWithoutValue())
+              endFormalParameter(null, null, null, o, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
+            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(async, null)
+            beginBlockFunctionBody({)
+              beginMetadataStar(const)
+              endMetadataStar(0)
+              handleIdentifier(dynamic, typeReference)
+              handleNoTypeArguments(local)
+              handleType(dynamic, null)
+              beginVariablesDeclaration(local, null, const)
+                handleIdentifier(local, localVariableDeclaration)
+                beginInitializedIdentifier(local)
+                  beginVariableInitializer(=)
+                    handleLiteralInt(0)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(local)
+              endVariablesDeclaration(1, ;)
+              beginMetadataStar(dynamic)
+              endMetadataStar(0)
+              handleIdentifier(dynamic, typeReference)
+              handleNoTypeArguments(variable)
+              handleType(dynamic, null)
+              beginVariablesDeclaration(variable, null, null)
+                handleIdentifier(variable, localVariableDeclaration)
+                beginInitializedIdentifier(variable)
+                  beginVariableInitializer(=)
+                    handleLiteralInt(0)
+                  endVariableInitializer(=)
+                endInitializedIdentifier(variable)
+              endVariablesDeclaration(1, ;)
+              beginSwitchStatement(switch)
+                handleIdentifier(o, expression)
+                handleNoTypeArguments())
+                handleNoArguments())
+                handleSend(o, ))
+                handleParenthesizedCondition((, null, null)
+                beginSwitchBlock({)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralBool(true)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(true)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralNull(null)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(null)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleThisExpression(this, expression)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(this)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleThisExpression(this, expression)
+                      handleNoTypeArguments(()
+                      beginArguments(()
+                      endArguments(0, (, ))
+                      handleSend(this, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleSuperExpression(super, expression)
+                      handleNoTypeArguments(()
+                      beginArguments(()
+                      endArguments(0, (, ))
+                      handleSend(super, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralInt(42)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(42)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralInt(42)
+                      handleUnaryPrefixExpression(-)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(42)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralDouble(42.5)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(42.5)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralDouble(42.5)
+                      handleUnaryPrefixExpression(-)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(42.5)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      beginLiteralString('foo')
+                      endLiteralString(0, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause('foo')
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      beginLiteralString('foo')
+                      endLiteralString(0, 'bar')
+                      beginLiteralString('bar')
+                      endLiteralString(0, :)
+                      handleStringJuxtaposition(case, 2)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause('bar')
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(value, expression)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(value, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(value)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleRecoverableError(InvalidConstantPatternNegation, value, value)
+                      handleIdentifier(value, expression)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(value, :)
+                      handleUnaryPrefixExpression(-)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(value)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(local, expression)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(local, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(local)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleRecoverableError(InvalidConstantPatternNegation, local, local)
+                      handleIdentifier(local, expression)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(local, :)
+                      handleUnaryPrefixExpression(-)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(local)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(func, expression)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(func, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(func)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(prefix, expression)
+                      handleNoTypeArguments(.)
+                      handleNoArguments(.)
+                      handleSend(prefix, .)
+                      handleIdentifier(value, expressionContinuation)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(value, :)
+                      handleEndingBinaryExpression(.)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(value)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleRecoverableError(InvalidConstantPatternNegation, prefix, prefix)
+                      handleIdentifier(prefix, expression)
+                      handleNoTypeArguments(.)
+                      handleNoArguments(.)
+                      handleSend(prefix, .)
+                      handleIdentifier(value, expressionContinuation)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(value, :)
+                      handleEndingBinaryExpression(.)
+                      handleUnaryPrefixExpression(-)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(value)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralInt(1)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(1)
+                    handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], +, +)
+                  endCaseExpression(case, null, :)
+                  beginSwitchCase(0, 19, case)
+                    handleRecoverableError(UnsupportedPrefixPlus, +, +)
+                    handleIdentifier(, expression)
+                    handleNoTypeArguments(+)
+                    handleNoArguments(+)
+                    handleSend(, +)
+                    beginBinaryExpression(+)
+                      handleLiteralInt(2)
+                    endBinaryExpression(+)
+                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                    handleExpressionStatement(;)
+                    handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ':'., Try inserting an identifier before ':'., {lexeme: :}], :, :)
+                    handleIdentifier(, expression)
+                    handleNoTypeArguments(:)
+                    handleNoArguments(:)
+                    handleSend(, :)
+                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                    handleExpressionStatement(;)
+                    handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
+                  endSwitchCase(0, 19, null, null, 2, case, case)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleLiteralInt(1)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(1)
+                    handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], *, *)
+                  endCaseExpression(case, null, :)
+                  beginSwitchCase(0, 1, case)
+                    handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '*'., Try inserting an identifier before '*'., {lexeme: *}], *, *)
+                    handleIdentifier(, expression)
+                    handleNoTypeArguments(*)
+                    handleNoArguments(*)
+                    handleSend(, *)
+                    beginBinaryExpression(*)
+                      handleLiteralInt(2)
+                    endBinaryExpression(*)
+                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                    handleExpressionStatement(;)
+                    handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ':'., Try inserting an identifier before ':'., {lexeme: :}], :, :)
+                    handleIdentifier(, expression)
+                    handleNoTypeArguments(:)
+                    handleNoArguments(:)
+                    handleSend(, :)
+                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                    handleExpressionStatement(;)
+                    handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
+                  endSwitchCase(0, 1, null, null, 2, case, case)
+                  beginCaseExpression(case)
+                    handleVoidKeyword(void)
+                    handleVariablePattern(null, fun, false)
+                    handleSwitchCaseNoWhenClause(fun)
+                    handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], (, ()
+                  endCaseExpression(case, null, :)
+                  beginSwitchCase(0, 1, case)
+                    handleNoTypeVariables(()
+                    beginFunctionExpression(()
+                      beginFormalParameters((, MemberKind.Local)
+                      endFormalParameters(0, (, ), MemberKind.Local)
+                      handleAsyncModifier(null, null)
+                      beginBlockFunctionBody({)
+                      endBlockFunctionBody(0, {, })
+                    endFunctionExpression((, :)
+                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
+                    handleExpressionStatement(;)
+                    handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ':'., Try inserting an identifier before ':'., {lexeme: :}], :, :)
+                    handleIdentifier(, expression)
+                    handleNoTypeArguments(:)
+                    handleNoArguments(:)
+                    handleSend(, :)
+                    handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
+                    handleExpressionStatement(;)
+                    handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
+                  endSwitchCase(0, 1, null, null, 2, case, case)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      beginAssert(assert, Assert.Expression)
+                        handleLiteralBool(false)
+                        handleRecoverableError(AssertAsExpression, assert, assert)
+                      endAssert(assert, Assert.Expression, (, null, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      beginSwitchExpression(switch)
+                        handleIdentifier(o, expression)
+                        handleNoTypeArguments())
+                        handleNoArguments())
+                        handleSend(o, ))
+                        handleParenthesizedCondition((, null, null)
+                        beginSwitchExpressionBlock({)
+                          beginSwitchExpressionCase()
+                            handleNoType({)
+                            handleVariablePattern(null, _, false)
+                            handleSwitchExpressionCasePattern(_)
+                            handleLiteralBool(true)
+                          endSwitchExpressionCase(null, =>, true)
+                        endSwitchExpressionBlock(1, {, })
+                      endSwitchExpression(switch, })
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(})
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      beginAwaitExpression(await)
+                        handleLiteralInt(0)
+                      endAwaitExpression(await, :)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(0)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}], !, !)
+                      handleLiteralBool(false)
+                      handleUnaryPrefixExpression(!)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(false)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}], ~, ~)
+                      handleLiteralInt(0)
+                      handleUnaryPrefixExpression(~)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(0)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(variable, expression)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(variable, :)
+                      handleUnaryPrefixAssignmentExpression(++)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(variable)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleIdentifier(Class, expression)
+                      handleNoTypeArguments(()
+                      beginArguments(()
+                      endArguments(0, (, ))
+                      handleSend(Class, :)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleIdentifier(Class, expression)
+                      handleNoTypeArguments(()
+                      beginArguments(()
+                        handleLiteralInt(0)
+                      endArguments(1, (, ))
+                      handleSend(Class, :)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleIdentifier(GenericClass, expression)
+                      handleNoTypeArguments(()
+                      beginArguments(()
+                      endArguments(0, (, ))
+                      handleSend(GenericClass, :)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleIdentifier(GenericClass, expression)
+                      handleNoTypeArguments(()
+                      beginArguments(()
+                        handleIdentifier(a, namedArgumentReference)
+                        handleLiteralInt(0)
+                        handleNamedArgument(:)
+                      endArguments(1, (, ))
+                      handleSend(GenericClass, :)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleIdentifier(GenericClass, expression)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      beginArguments(()
+                      endArguments(0, (, ))
+                      handleSend(GenericClass, :)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleIdentifier(GenericClass, expression)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      beginArguments(()
+                        handleIdentifier(a, namedArgumentReference)
+                        handleLiteralInt(0)
+                        handleNamedArgument(:)
+                      endArguments(1, (, ))
+                      handleSend(GenericClass, :)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginImplicitCreationExpression(GenericClass)
+                        handleIdentifier(GenericClass, constructorReference)
+                        beginConstructorReference(GenericClass)
+                          beginTypeArguments(<)
+                            handleIdentifier(int, typeReference)
+                            handleNoTypeArguments(>)
+                            handleType(int, null)
+                          endTypeArguments(1, <, >)
+                          handleNewAsIdentifier(new)
+                          handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
+                        endConstructorReference(GenericClass, ., (, ConstructorReferenceContext.Implicit)
+                        beginArguments(()
+                        endArguments(0, (, ))
+                      endImplicitCreationExpression(GenericClass, <)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginImplicitCreationExpression(GenericClass)
+                        handleIdentifier(GenericClass, constructorReference)
+                        beginConstructorReference(GenericClass)
+                          beginTypeArguments(<)
+                            handleIdentifier(int, typeReference)
+                            handleNoTypeArguments(>)
+                            handleType(int, null)
+                          endTypeArguments(1, <, >)
+                          handleNewAsIdentifier(new)
+                          handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
+                        endConstructorReference(GenericClass, ., (, ConstructorReferenceContext.Implicit)
+                        beginArguments(()
+                          handleIdentifier(a, namedArgumentReference)
+                          handleLiteralInt(1)
+                          handleNamedArgument(:)
+                        endArguments(1, (, ))
+                      endImplicitCreationExpression(GenericClass, <)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleNoTypeArguments([])
+                      handleLiteralList(0, [, null, ])
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(])
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      handleLiteralList(0, [, null, ])
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(])
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleNoTypeArguments({)
+                      handleLiteralSetOrMap(0, {, null, }, false)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(})
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(,)
+                        handleType(int, null)
+                        handleIdentifier(String, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(String, null)
+                      endTypeArguments(2, <, >)
+                      handleLiteralSetOrMap(0, {, null, }, false)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(})
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstExpression(const)
+                        handleIdentifier(Class, constructorReference)
+                        beginConstructorReference(Class)
+                          handleNoTypeArguments(()
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(Class, null, (, ConstructorReferenceContext.Const)
+                        beginArguments(()
+                        endArguments(0, (, ))
+                      endConstExpression(const)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstExpression(const)
+                        handleIdentifier(Class, constructorReference)
+                        beginConstructorReference(Class)
+                          handleNoTypeArguments(()
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(Class, null, (, ConstructorReferenceContext.Const)
+                        beginArguments(()
+                          handleLiteralInt(0)
+                        endArguments(1, (, ))
+                      endConstExpression(const)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstExpression(const)
+                        handleIdentifier(GenericClass, constructorReference)
+                        beginConstructorReference(GenericClass)
+                          handleNoTypeArguments(()
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                        beginArguments(()
+                        endArguments(0, (, ))
+                      endConstExpression(const)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstExpression(const)
+                        handleIdentifier(GenericClass, constructorReference)
+                        beginConstructorReference(GenericClass)
+                          handleNoTypeArguments(()
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                        beginArguments(()
+                          handleIdentifier(a, namedArgumentReference)
+                          handleLiteralInt(0)
+                          handleNamedArgument(:)
+                        endArguments(1, (, ))
+                      endConstExpression(const)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstExpression(const)
+                        handleIdentifier(GenericClass, constructorReference)
+                        beginConstructorReference(GenericClass)
+                          beginTypeArguments(<)
+                            handleIdentifier(int, typeReference)
+                            handleNoTypeArguments(>)
+                            handleType(int, null)
+                          endTypeArguments(1, <, >)
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                        beginArguments(()
+                        endArguments(0, (, ))
+                      endConstExpression(const)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstExpression(const)
+                        handleIdentifier(GenericClass, constructorReference)
+                        beginConstructorReference(GenericClass)
+                          beginTypeArguments(<)
+                            handleIdentifier(int, typeReference)
+                            handleNoTypeArguments(>)
+                            handleType(int, null)
+                          endTypeArguments(1, <, >)
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                        beginArguments(()
+                          handleIdentifier(a, namedArgumentReference)
+                          handleLiteralInt(0)
+                          handleNamedArgument(:)
+                        endArguments(1, (, ))
+                      endConstExpression(const)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstLiteral([])
+                        handleNoTypeArguments([])
+                        handleLiteralList(0, [, const, ])
+                      endConstLiteral(:)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(])
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstLiteral(<)
+                        beginTypeArguments(<)
+                          handleIdentifier(int, typeReference)
+                          handleNoTypeArguments(>)
+                          handleType(int, null)
+                        endTypeArguments(1, <, >)
+                        handleLiteralList(0, [, const, ])
+                      endConstLiteral(:)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(])
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstLiteral({)
+                        handleNoTypeArguments({)
+                        handleLiteralSetOrMap(0, {, const, }, false)
+                      endConstLiteral(:)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(})
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstLiteral(<)
+                        beginTypeArguments(<)
+                          handleIdentifier(int, typeReference)
+                          handleNoTypeArguments(,)
+                          handleType(int, null)
+                          handleIdentifier(String, typeReference)
+                          handleNoTypeArguments(>)
+                          handleType(String, null)
+                        endTypeArguments(2, <, >)
+                        handleLiteralSetOrMap(0, {, const, }, false)
+                      endConstLiteral(:)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause(})
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginNewExpression(new)
+                        handleIdentifier(Class, constructorReference)
+                        beginConstructorReference(Class)
+                          handleNoTypeArguments(()
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(Class, null, (, ConstructorReferenceContext.New)
+                        beginArguments(()
+                        endArguments(0, (, ))
+                      endNewExpression(new)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      beginNewExpression(new)
+                        handleIdentifier(Class, constructorReference)
+                        beginConstructorReference(Class)
+                          handleNoTypeArguments(()
+                          handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                        endConstructorReference(Class, null, (, ConstructorReferenceContext.New)
+                        beginArguments(()
+                        endArguments(0, (, ))
+                      endNewExpression(new)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleRecoverableError(InvalidConstantPatternEmptyRecordLiteral, ), ))
+                      endRecordLiteral((, 0, null)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                      beginConstLiteral(()
+                        beginParenthesizedExpressionOrRecordLiteral(()
+                        endRecordLiteral((, 0, const)
+                      endConstLiteral(:)
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleLiteralInt(1)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleLiteralInt(1)
+                        handleUnaryPrefixExpression(-)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleIdentifier(value, expression)
+                        handleNoTypeArguments())
+                        handleNoArguments())
+                        handleSend(value, ))
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleIdentifier(value, expression)
+                        handleNoTypeArguments())
+                        handleNoArguments())
+                        handleSend(value, ))
+                        handleUnaryPrefixExpression(-)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleLiteralInt(1)
+                        beginBinaryExpression(+)
+                          handleLiteralInt(2)
+                        endBinaryExpression(+)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(GenericClass, expression)
+                      handleNoTypeArguments(<)
+                      handleNoArguments(<)
+                      handleSend(GenericClass, <)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                      handleTypeArgumentApplication(<)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(>)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(prefix, expression)
+                      handleNoTypeArguments(.)
+                      handleNoArguments(.)
+                      handleSend(prefix, .)
+                      handleIdentifier(GenericClass, expressionContinuation)
+                      handleNoTypeArguments(<)
+                      handleNoArguments(<)
+                      handleSend(GenericClass, <)
+                      handleEndingBinaryExpression(.)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                      handleTypeArgumentApplication(<)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(>)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(GenericClass, expression)
+                      handleNoTypeArguments(<)
+                      handleNoArguments(<)
+                      handleSend(GenericClass, <)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                      handleTypeArgumentApplication(<)
+                      handleNewAsIdentifier(new)
+                      handleIdentifier(new, expressionContinuation)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(new, :)
+                      handleEndingBinaryExpression(.)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(new)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(null)
+                      handleIdentifier(prefix, expression)
+                      handleNoTypeArguments(.)
+                      handleNoArguments(.)
+                      handleSend(prefix, .)
+                      handleIdentifier(GenericClass, expressionContinuation)
+                      handleNoTypeArguments(<)
+                      handleNoArguments(<)
+                      handleSend(GenericClass, <)
+                      handleEndingBinaryExpression(.)
+                      beginTypeArguments(<)
+                        handleIdentifier(int, typeReference)
+                        handleNoTypeArguments(>)
+                        handleType(int, null)
+                      endTypeArguments(1, <, >)
+                      handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                      handleTypeArgumentApplication(<)
+                      handleNewAsIdentifier(new)
+                      handleIdentifier(new, expressionContinuation)
+                      handleNoTypeArguments(:)
+                      handleNoArguments(:)
+                      handleSend(new, :)
+                      handleEndingBinaryExpression(.)
+                    endConstantPattern(null)
+                    handleSwitchCaseNoWhenClause(new)
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleIdentifier(GenericClass, expression)
+                        handleNoTypeArguments(<)
+                        handleNoArguments(<)
+                        handleSend(GenericClass, <)
+                        beginTypeArguments(<)
+                          handleIdentifier(int, typeReference)
+                          handleNoTypeArguments(>)
+                          handleType(int, null)
+                        endTypeArguments(1, <, >)
+                        handleTypeArgumentApplication(<)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleIdentifier(prefix, expression)
+                        handleNoTypeArguments(.)
+                        handleNoArguments(.)
+                        handleSend(prefix, .)
+                        handleIdentifier(GenericClass, expressionContinuation)
+                        handleNoTypeArguments(<)
+                        handleNoArguments(<)
+                        handleSend(GenericClass, <)
+                        handleEndingBinaryExpression(.)
+                        beginTypeArguments(<)
+                          handleIdentifier(int, typeReference)
+                          handleNoTypeArguments(>)
+                          handleType(int, null)
+                        endTypeArguments(1, <, >)
+                        handleTypeArgumentApplication(<)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleIdentifier(GenericClass, expression)
+                        handleNoTypeArguments(<)
+                        handleNoArguments(<)
+                        handleSend(GenericClass, <)
+                        beginTypeArguments(<)
+                          handleIdentifier(int, typeReference)
+                          handleNoTypeArguments(>)
+                          handleType(int, null)
+                        endTypeArguments(1, <, >)
+                        handleTypeArgumentApplication(<)
+                        handleNewAsIdentifier(new)
+                        handleIdentifier(new, expressionContinuation)
+                        handleNoTypeArguments())
+                        handleNoArguments())
+                        handleSend(new, ))
+                        handleEndingBinaryExpression(.)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginCaseExpression(case)
+                    beginConstantPattern(const)
+                      beginParenthesizedExpressionOrRecordLiteral(()
+                        handleIdentifier(prefix, expression)
+                        handleNoTypeArguments(.)
+                        handleNoArguments(.)
+                        handleSend(prefix, .)
+                        handleIdentifier(GenericClass, expressionContinuation)
+                        handleNoTypeArguments(<)
+                        handleNoArguments(<)
+                        handleSend(GenericClass, <)
+                        handleEndingBinaryExpression(.)
+                        beginTypeArguments(<)
+                          handleIdentifier(int, typeReference)
+                          handleNoTypeArguments(>)
+                          handleType(int, null)
+                        endTypeArguments(1, <, >)
+                        handleTypeArgumentApplication(<)
+                        handleNewAsIdentifier(new)
+                        handleIdentifier(new, expressionContinuation)
+                        handleNoTypeArguments())
+                        handleNoArguments())
+                        handleSend(new, ))
+                        handleEndingBinaryExpression(.)
+                      endParenthesizedExpression(()
+                    endConstantPattern(const)
+                    handleSwitchCaseNoWhenClause())
+                  endCaseExpression(case, null, :)
+                  beginSwitchCase(0, 45, case)
+                    handleIdentifier(print, expression)
+                    handleNoTypeArguments(()
+                    beginArguments(()
+                      handleLiteralInt(0)
+                    endArguments(1, (, ))
+                    handleSend(print, ;)
+                    handleExpressionStatement(;)
+                  endSwitchCase(0, 45, null, null, 1, case, })
+                endSwitchBlock(4, {, })
+              endSwitchStatement(switch, })
+            endBlockFunctionBody(3, {, })
+          endClassMethod(null, test, (, null, })
+        endMember()
+      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 3, {, })
+    endClassDeclaration(class, })
+  endTopLevelDeclaration(class)
+  beginMetadataStar(class)
+  endMetadataStar(0)
+  beginClassOrMixinOrNamedMixinApplicationPrelude(class)
+    handleIdentifier(GenericClass, classOrMixinDeclaration)
+    beginTypeVariables(<)
+      beginMetadataStar(T)
+      endMetadataStar(0)
+      handleIdentifier(T, typeVariableDeclaration)
+      beginTypeVariable(T)
+        handleTypeVariablesDefined(T, 1)
+        handleNoType(T)
+      endTypeVariable(>, 0, null, null)
+    endTypeVariables(<, >)
+    beginClassDeclaration(class, null, null, null, null, null, null, null, null, null, GenericClass)
+      handleNoType(>)
+      handleClassExtends(null, 1)
+      handleClassNoWithClause()
+      handleImplements(null, 0)
+      handleClassHeader(class, class, null)
+      beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
+        beginMetadataStar(const)
+        endMetadataStar(0)
+        beginMember()
+          beginMethod(DeclarationKind.Class, null, null, null, null, const, null, GenericClass)
+            handleNoType(const)
+            handleIdentifier(GenericClass, methodDeclaration)
+            handleNoTypeVariables(()
+            beginFormalParameters((, MemberKind.NonStaticMethod)
+              beginOptionalFormalParameters({)
+                beginMetadataStar(a)
+                endMetadataStar(0)
+                beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
+                  handleNoType({)
+                  handleIdentifier(a, formalParameterDeclaration)
+                  handleFormalParameterWithoutValue(})
+                endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
+              endOptionalFormalParameters(1, {, })
+            endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+            handleNoInitializers()
+            handleAsyncModifier(null, null)
+            handleEmptyFunctionBody(;)
+          endClassConstructor(null, const, (, null, ;)
+        endMember()
+      endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
+    endClassDeclaration(class, })
+  endTopLevelDeclaration()
+endCompilationUnit(5, )

pkg/front_end/parser_testcases/patterns/const_patterns.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/const_patterns.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.intertwined.expect
new file mode 100644
index 0000000..092b9a9
--- /dev/null
+++ b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.intertwined.expect
@@ -0,0 +1,2508 @@
+parseUnit(import)
+  skipErrorTokens(import)
+  listener: beginCompilationUnit(import)
+  syntheticPreviousToken(import)
+  parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
+    parseMetadataStar()
+      listener: beginMetadataStar(import)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(, import, null, null, null, null, null, Instance of 'DirectiveContext')
+      parseImport(import)
+        listener: beginUncategorizedTopLevelDeclaration(import)
+        listener: beginImport(import)
+        ensureLiteralString(import)
+          parseLiteralString(import)
+            parseSingleLiteralString(import)
+              listener: beginLiteralString('const_patterns.dart')
+              listener: endLiteralString(0, as)
+        parseConditionalUriStar('const_patterns.dart')
+          listener: beginConditionalUris(as)
+          listener: endConditionalUris(0)
+        parseImportPrefixOpt('const_patterns.dart')
+          ensureIdentifier(as, importPrefixDeclaration)
+            listener: handleIdentifier(prefix, importPrefixDeclaration)
+          listener: handleImportPrefix(null, as)
+        parseCombinatorStar(prefix)
+          listener: beginCombinators(;)
+          listener: endCombinators(0)
+        listener: endImport(import, null, ;)
+  listener: endTopLevelDeclaration(const)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(const)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(const)
+      parseFields(;, null, null, null, null, null, null, const, const, Instance of 'SimpleType', value, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(DeclarationKind.TopLevel, null, null, null, null, null, null, const, ;)
+        listener: handleIdentifier(int, typeReference)
+        listener: handleNoTypeArguments(value)
+        listener: handleType(int, null)
+        ensureIdentifierPotentiallyRecovered(int, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(value, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(value, value, null, null, null, null, const, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            looksLikeOuterPatternEquals(=)
+              skipOuterPattern(=)
+            parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+              parseUnaryExpression(=, true, ConstantPatternContext.none)
+                parsePrimary(=, expression, ConstantPatternContext.none)
+                  parseLiteralInt(=)
+                    listener: handleLiteralInt(42)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, const, 1, const, ;)
+  listener: endTopLevelDeclaration(void)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(void)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(void)
+      parseTopLevelMethod(;, null, null, ;, Instance of 'VoidType', null, func, false)
+        listener: beginTopLevelMethod(;, null, null)
+        listener: handleVoidKeyword(void)
+        ensureIdentifierPotentiallyRecovered(void, topLevelFunctionDeclaration, false)
+          listener: handleIdentifier(func, topLevelFunctionDeclaration)
+        parseMethodTypeVar(func)
+          listener: handleNoTypeVariables(()
+        parseGetterOrFormalParameters(func, func, false, MemberKind.TopLevelMethod)
+          parseFormalParameters(func, 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(}, })
+          listener: endBlockFunctionBody(0, {, })
+        listener: endTopLevelMethod(void, null, })
+  listener: endTopLevelDeclaration(class)
+  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
+    parseMetadataStar(})
+      listener: beginMetadataStar(class)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(}, class, null, null, null, null, null, Instance of 'DirectiveContext')
+      parseClassOrNamedMixinApplication(null, null, null, null, null, null, null, null, null, class)
+        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(Class, classOrMixinDeclaration)
+        listener: handleNoTypeVariables({)
+        listener: beginClassDeclaration(class, null, null, null, null, null, null, null, null, null, Class)
+        parseClass(Class, class, class, Class)
+          parseClassHeaderOpt(Class, class, class)
+            parseClassExtendsOpt(Class)
+              listener: handleNoType(Class)
+              listener: handleClassExtends(null, 1)
+            parseClassWithClauseOpt(Class)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinOrEnumImplementsOpt(Class)
+              listener: handleImplements(null, 0)
+            listener: handleClassHeader(class, class, null)
+          parseClassOrMixinOrExtensionBody(Class, DeclarationKind.Class, Class)
+            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
+            notEofOrValue(}, const)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, Class)
+              parseMetadataStar({)
+                listener: beginMetadataStar(const)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod({, null, null, null, null, null, null, const, const, Instance of 'NoType', null, Class, DeclarationKind.Class, Class, false)
+                listener: beginMethod(DeclarationKind.Class, null, null, null, null, const, null, Class)
+                listener: handleNoType(const)
+                ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
+                  listener: handleIdentifier(Class, methodDeclaration)
+                parseQualifiedRestOpt(Class, methodDeclarationContinuation)
+                parseMethodTypeVar(Class)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(Class, Class, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(Class, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseOptionalPositionalParameters((, MemberKind.NonStaticMethod)
+                        listener: beginOptionalFormalParameters([)
+                        parseFormalParameter([, FormalParameterKind.optionalPositional, MemberKind.NonStaticMethod)
+                          parseMetadataStar([)
+                            listener: beginMetadataStar(a)
+                            listener: endMetadataStar(0)
+                          listener: beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
+                          listener: handleNoType([)
+                          ensureIdentifier([, formalParameterDeclaration)
+                            listener: handleIdentifier(a, formalParameterDeclaration)
+                          listener: handleFormalParameterWithoutValue(])
+                          listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalPositional, MemberKind.NonStaticMethod)
+                        listener: endOptionalFormalParameters(1, [, ])
+                      ensureCloseParen(], ()
+                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: handleEmptyFunctionBody(;)
+                listener: endClassConstructor(null, const, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, call)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(;, DeclarationKind.Class, Class)
+              parseMetadataStar(;)
+                listener: beginMetadataStar(call)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(;, null, null, null, null, null, null, null, ;, Instance of 'NoType', null, call, DeclarationKind.Class, Class, false)
+                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, call)
+                listener: handleNoType(;)
+                ensureIdentifierPotentiallyRecovered(;, methodDeclaration, false)
+                  listener: handleIdentifier(call, methodDeclaration)
+                parseQualifiedRestOpt(call, methodDeclarationContinuation)
+                parseMethodTypeVar(call)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(call, call, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(call, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(0, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(0, {, })
+                listener: endClassMethod(null, call, (, null, })
+              listener: endMember()
+            notEofOrValue(}, test)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl(}, DeclarationKind.Class, Class)
+              parseMetadataStar(})
+                listener: beginMetadataStar(test)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              isReservedKeyword(()
+              parseMethod(}, null, null, null, null, null, null, null, }, Instance of 'NoType', null, test, DeclarationKind.Class, Class, false)
+                listener: beginMethod(DeclarationKind.Class, null, null, null, null, null, null, test)
+                listener: handleNoType(})
+                ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
+                  listener: handleIdentifier(test, methodDeclaration)
+                parseQualifiedRestOpt(test, methodDeclarationContinuation)
+                parseMethodTypeVar(test)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(test, test, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(test, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseFormalParameter((, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
+                        parseMetadataStar(()
+                          listener: beginMetadataStar(o)
+                          listener: endMetadataStar(0)
+                        listener: beginFormalParameter(o, MemberKind.NonStaticMethod, null, null, null)
+                        listener: handleNoType(()
+                        ensureIdentifier((, formalParameterDeclaration)
+                          listener: handleIdentifier(o, formalParameterDeclaration)
+                        listener: handleFormalParameterWithoutValue())
+                        listener: endFormalParameter(null, null, null, o, null, null, FormalParameterKind.requiredPositional, MemberKind.NonStaticMethod)
+                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(async, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(async, false, false)
+                  listener: beginBlockFunctionBody({)
+                  notEofOrValue(}, const)
+                  parseStatement({)
+                    parseStatementX({)
+                      parseExpressionStatementOrConstDeclaration({)
+                        parseExpressionStatementOrDeclarationAfterModifiers(const, {, null, const, Instance of 'SimpleType', null)
+                          looksLikeLocalFunction(local)
+                          listener: beginMetadataStar(const)
+                          listener: endMetadataStar(0)
+                          listener: handleIdentifier(dynamic, typeReference)
+                          listener: handleNoTypeArguments(local)
+                          listener: handleType(dynamic, null)
+                          listener: beginVariablesDeclaration(local, null, const)
+                          parseVariablesDeclarationRest(dynamic, true)
+                            parseOptionallyInitializedIdentifier(dynamic)
+                              ensureIdentifier(dynamic, localVariableDeclaration)
+                                listener: handleIdentifier(local, localVariableDeclaration)
+                              listener: beginInitializedIdentifier(local)
+                              parseVariableInitializerOpt(local)
+                                listener: beginVariableInitializer(=)
+                                parseExpression(=)
+                                  looksLikeOuterPatternEquals(=)
+                                    skipOuterPattern(=)
+                                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                      parsePrimary(=, expression, ConstantPatternContext.none)
+                                        parseLiteralInt(=)
+                                          listener: handleLiteralInt(0)
+                                listener: endVariableInitializer(=)
+                              listener: endInitializedIdentifier(local)
+                            ensureSemicolon(0)
+                            listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, dynamic)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseExpressionStatementOrDeclaration(;, null)
+                        parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
+                          looksLikeLocalFunction(variable)
+                          listener: beginMetadataStar(dynamic)
+                          listener: endMetadataStar(0)
+                          listener: handleIdentifier(dynamic, typeReference)
+                          listener: handleNoTypeArguments(variable)
+                          listener: handleType(dynamic, null)
+                          listener: beginVariablesDeclaration(variable, null, null)
+                          parseVariablesDeclarationRest(dynamic, true)
+                            parseOptionallyInitializedIdentifier(dynamic)
+                              ensureIdentifier(dynamic, localVariableDeclaration)
+                                listener: handleIdentifier(variable, localVariableDeclaration)
+                              listener: beginInitializedIdentifier(variable)
+                              parseVariableInitializerOpt(variable)
+                                listener: beginVariableInitializer(=)
+                                parseExpression(=)
+                                  looksLikeOuterPatternEquals(=)
+                                    skipOuterPattern(=)
+                                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                      parsePrimary(=, expression, ConstantPatternContext.none)
+                                        parseLiteralInt(=)
+                                          listener: handleLiteralInt(0)
+                                listener: endVariableInitializer(=)
+                              listener: endInitializedIdentifier(variable)
+                            ensureSemicolon(0)
+                            listener: endVariablesDeclaration(1, ;)
+                  notEofOrValue(}, switch)
+                  parseStatement(;)
+                    parseStatementX(;)
+                      parseSwitchStatement(;)
+                        listener: beginSwitchStatement(switch)
+                        ensureParenthesizedCondition(switch, allowCase: false)
+                          parseExpressionInParenthesisRest((, allowCase: false)
+                            parseExpression(()
+                              looksLikeOuterPatternEquals(()
+                                skipOuterPattern(()
+                                  skipObjectPatternRest(o)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(o, expression)
+                                        listener: handleNoTypeArguments())
+                                        parseArgumentsOpt(o)
+                                          listener: handleNoArguments())
+                                        listener: handleSend(o, ))
+                            ensureCloseParen(o, ()
+                            listener: handleParenthesizedCondition((, null, null)
+                        parseSwitchBlock())
+                          ensureBlock(), null, switch statement)
+                          listener: beginSwitchBlock({)
+                          notEofOrValue(}, case)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralBool(case)
+                                      listener: handleLiteralBool(true)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(true)
+                          ensureColon(true)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralNull(case)
+                                      listener: handleLiteralNull(null)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(null)
+                          ensureColon(null)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseThisExpression(case, expression)
+                                      listener: handleThisExpression(this, expression)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(this)
+                          ensureColon(this)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseThisExpression(case, expression)
+                                      listener: handleThisExpression(this, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArguments(this)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: handleSend(this, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSuperExpression(case, expression)
+                                      listener: handleSuperExpression(super, expression)
+                                      listener: handleNoTypeArguments(()
+                                      parseArguments(super)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: handleSend(super, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralInt(case)
+                                      listener: handleLiteralInt(42)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(42)
+                          ensureColon(42)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
+                                    parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
+                                      parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
+                                        parseLiteralInt(-)
+                                          listener: handleLiteralInt(42)
+                                  listener: handleUnaryPrefixExpression(-)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(42)
+                          ensureColon(42)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralDouble(case)
+                                      listener: handleLiteralDouble(42.5)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(42.5)
+                          ensureColon(42.5)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
+                                    parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
+                                      parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
+                                        parseLiteralDouble(-)
+                                          listener: handleLiteralDouble(42.5)
+                                  listener: handleUnaryPrefixExpression(-)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(42.5)
+                          ensureColon(42.5)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralString(case)
+                                      parseSingleLiteralString(case)
+                                        listener: beginLiteralString('foo')
+                                        listener: endLiteralString(0, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause('foo')
+                          ensureColon('foo')
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralString(case)
+                                      parseSingleLiteralString(case)
+                                        listener: beginLiteralString('foo')
+                                        listener: endLiteralString(0, 'bar')
+                                      parseSingleLiteralString('foo')
+                                        listener: beginLiteralString('bar')
+                                        listener: endLiteralString(0, :)
+                                      listener: handleStringJuxtaposition(case, 2)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause('bar')
+                          ensureColon('bar')
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(value, expression)
+                                        listener: handleNoTypeArguments(:)
+                                        parseArgumentsOpt(value)
+                                          listener: handleNoArguments(:)
+                                        listener: handleSend(value, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(value)
+                          ensureColon(value)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
+                                    parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
+                                      parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
+                                        reportRecoverableError(value, InvalidConstantPatternNegation)
+                                          listener: handleRecoverableError(InvalidConstantPatternNegation, value, value)
+                                        parseSendOrFunctionLiteral(-, expression)
+                                          parseSend(-, expression)
+                                            isNextIdentifier(-)
+                                            ensureIdentifier(-, expression)
+                                              listener: handleIdentifier(value, expression)
+                                            listener: handleNoTypeArguments(:)
+                                            parseArgumentsOpt(value)
+                                              listener: handleNoArguments(:)
+                                            listener: handleSend(value, :)
+                                  listener: handleUnaryPrefixExpression(-)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(value)
+                          ensureColon(value)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(local, expression)
+                                        listener: handleNoTypeArguments(:)
+                                        parseArgumentsOpt(local)
+                                          listener: handleNoArguments(:)
+                                        listener: handleSend(local, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(local)
+                          ensureColon(local)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
+                                    parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
+                                      parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
+                                        reportRecoverableError(local, InvalidConstantPatternNegation)
+                                          listener: handleRecoverableError(InvalidConstantPatternNegation, local, local)
+                                        parseSendOrFunctionLiteral(-, expression)
+                                          parseSend(-, expression)
+                                            isNextIdentifier(-)
+                                            ensureIdentifier(-, expression)
+                                              listener: handleIdentifier(local, expression)
+                                            listener: handleNoTypeArguments(:)
+                                            parseArgumentsOpt(local)
+                                              listener: handleNoArguments(:)
+                                            listener: handleSend(local, :)
+                                  listener: handleUnaryPrefixExpression(-)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(local)
+                          ensureColon(local)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(func, expression)
+                                        listener: handleNoTypeArguments(:)
+                                        parseArgumentsOpt(func)
+                                          listener: handleNoArguments(:)
+                                        listener: handleSend(func, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(func)
+                          ensureColon(func)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(prefix, expression)
+                                        listener: handleNoTypeArguments(.)
+                                        parseArgumentsOpt(prefix)
+                                          listener: handleNoArguments(.)
+                                        listener: handleSend(prefix, .)
+                                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                  parseSendOrFunctionLiteral(., expressionContinuation)
+                                    parseSend(., expressionContinuation)
+                                      isNextIdentifier(.)
+                                      ensureIdentifier(., expressionContinuation)
+                                        listener: handleIdentifier(value, expressionContinuation)
+                                      listener: handleNoTypeArguments(:)
+                                      parseArgumentsOpt(value)
+                                        listener: handleNoArguments(:)
+                                      listener: handleSend(value, :)
+                                listener: handleEndingBinaryExpression(.)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(value)
+                          ensureColon(value)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrecedenceExpression(-, 16, false, ConstantPatternContext.numericLiteralOnly)
+                                    parseUnaryExpression(-, false, ConstantPatternContext.numericLiteralOnly)
+                                      parsePrimary(-, expression, ConstantPatternContext.numericLiteralOnly)
+                                        reportRecoverableError(prefix, InvalidConstantPatternNegation)
+                                          listener: handleRecoverableError(InvalidConstantPatternNegation, prefix, prefix)
+                                        parseSendOrFunctionLiteral(-, expression)
+                                          parseSend(-, expression)
+                                            isNextIdentifier(-)
+                                            ensureIdentifier(-, expression)
+                                              listener: handleIdentifier(prefix, expression)
+                                            listener: handleNoTypeArguments(.)
+                                            parseArgumentsOpt(prefix)
+                                              listener: handleNoArguments(.)
+                                            listener: handleSend(prefix, .)
+                                    parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                      parseSendOrFunctionLiteral(., expressionContinuation)
+                                        parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
+                                          ensureIdentifier(., expressionContinuation)
+                                            listener: handleIdentifier(value, expressionContinuation)
+                                          listener: handleNoTypeArguments(:)
+                                          parseArgumentsOpt(value)
+                                            listener: handleNoArguments(:)
+                                          listener: handleSend(value, :)
+                                    listener: handleEndingBinaryExpression(.)
+                                  listener: handleUnaryPrefixExpression(-)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(value)
+                          ensureColon(value)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralInt(case)
+                                      listener: handleLiteralInt(1)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(1)
+                          ensureColon(1)
+                            rewriteAndRecover(1, Message[ExpectedButGot, Expected ':' before this., null, {string: :}], :)
+                              reportRecoverableError(+, Message[ExpectedButGot, Expected ':' before this., null, {string: :}])
+                                listener: handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], +, +)
+                              rewriter()
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(+)
+                          parseStatementsInSwitchCase(:, +, case, 0, 19, null, null)
+                            listener: beginSwitchCase(0, 19, case)
+                            parseStatement(:)
+                              parseStatementX(:)
+                                parseExpressionStatementOrDeclaration(:, null)
+                                  parseExpressionStatementOrDeclarationAfterModifiers(:, :, null, null, null, null)
+                                    looksLikeLocalFunction(+)
+                                    parseExpressionStatement(:)
+                                      parseExpression(:)
+                                        looksLikeOuterPatternEquals(:)
+                                          skipOuterPattern(:)
+                                        parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                            rewriteAndRecover(:, UnsupportedPrefixPlus, )
+                                              reportRecoverableError(+, UnsupportedPrefixPlus)
+                                                listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
+                                              rewriter()
+                                            parsePrimary(:, expression, ConstantPatternContext.none)
+                                              parseSendOrFunctionLiteral(:, expression)
+                                                parseSend(:, expression)
+                                                  isNextIdentifier(:)
+                                                  ensureIdentifier(:, expression)
+                                                    listener: handleIdentifier(, expression)
+                                                  listener: handleNoTypeArguments(+)
+                                                  parseArgumentsOpt()
+                                                    listener: handleNoArguments(+)
+                                                  listener: handleSend(, +)
+                                          listener: beginBinaryExpression(+)
+                                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                              parsePrimary(+, expression, ConstantPatternContext.none)
+                                                parseLiteralInt(+)
+                                                  listener: handleLiteralInt(2)
+                                          listener: endBinaryExpression(+)
+                                      ensureSemicolon(2)
+                                        reportRecoverableError(2, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                                        rewriter()
+                                      listener: handleExpressionStatement(;)
+                            peekPastLabels(:)
+                            parseStatement(;)
+                              parseStatementX(;)
+                                parseExpressionStatementOrDeclaration(;, null)
+                                  parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
+                                    looksLikeLocalFunction(:)
+                                    parseExpressionStatement(;)
+                                      parseExpression(;)
+                                        looksLikeOuterPatternEquals(;)
+                                          skipOuterPattern(;)
+                                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                            parsePrimary(;, expression, ConstantPatternContext.none)
+                                              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(, :)
+                                      ensureSemicolon()
+                                        reportRecoverableError(2, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                                        rewriter()
+                                      listener: handleExpressionStatement(;)
+                            reportRecoverableError(:, Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}])
+                              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
+                            peekPastLabels(case)
+                            listener: endSwitchCase(0, 19, null, null, 2, case, case)
+                          notEofOrValue(}, case)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseLiteralInt(case)
+                                      listener: handleLiteralInt(1)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(1)
+                          ensureColon(1)
+                            rewriteAndRecover(1, Message[ExpectedButGot, Expected ':' before this., null, {string: :}], :)
+                              reportRecoverableError(*, Message[ExpectedButGot, Expected ':' before this., null, {string: :}])
+                                listener: handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], *, *)
+                              rewriter()
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(*)
+                          parseStatementsInSwitchCase(:, *, case, 0, 1, null, null)
+                            listener: beginSwitchCase(0, 1, case)
+                            parseStatement(:)
+                              parseStatementX(:)
+                                parseExpressionStatementOrDeclaration(:, null)
+                                  parseExpressionStatementOrDeclarationAfterModifiers(:, :, null, null, null, null)
+                                    looksLikeLocalFunction(*)
+                                    parseExpressionStatement(:)
+                                      parseExpression(:)
+                                        looksLikeOuterPatternEquals(:)
+                                          skipOuterPattern(:)
+                                        parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                            parsePrimary(:, expression, ConstantPatternContext.none)
+                                              parseSend(:, expression)
+                                                isNextIdentifier(:)
+                                                ensureIdentifier(:, expression)
+                                                  reportRecoverableErrorWithToken(*, Instance of 'Template<(Token) => Message>')
+                                                    listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '*'., Try inserting an identifier before '*'., {lexeme: *}], *, *)
+                                                  rewriter()
+                                                  listener: handleIdentifier(, expression)
+                                                listener: handleNoTypeArguments(*)
+                                                parseArgumentsOpt()
+                                                  listener: handleNoArguments(*)
+                                                listener: handleSend(, *)
+                                          listener: beginBinaryExpression(*)
+                                          parsePrecedenceExpression(*, 15, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(*, true, ConstantPatternContext.none)
+                                              parsePrimary(*, expression, ConstantPatternContext.none)
+                                                parseLiteralInt(*)
+                                                  listener: handleLiteralInt(2)
+                                          listener: endBinaryExpression(*)
+                                      ensureSemicolon(2)
+                                        reportRecoverableError(2, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                                        rewriter()
+                                      listener: handleExpressionStatement(;)
+                            peekPastLabels(:)
+                            parseStatement(;)
+                              parseStatementX(;)
+                                parseExpressionStatementOrDeclaration(;, null)
+                                  parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
+                                    looksLikeLocalFunction(:)
+                                    parseExpressionStatement(;)
+                                      parseExpression(;)
+                                        looksLikeOuterPatternEquals(;)
+                                          skipOuterPattern(;)
+                                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                            parsePrimary(;, expression, ConstantPatternContext.none)
+                                              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(, :)
+                                      ensureSemicolon()
+                                        reportRecoverableError(2, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 2, 2)
+                                        rewriter()
+                                      listener: handleExpressionStatement(;)
+                            reportRecoverableError(:, Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}])
+                              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
+                            peekPastLabels(case)
+                            listener: endSwitchCase(0, 1, null, null, 2, case, case)
+                          notEofOrValue(}, case)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              parseVariablePattern(case, PatternContext.matching, typeInfo: Instance of 'VoidType')
+                                listener: handleVoidKeyword(void)
+                                listener: handleVariablePattern(null, fun, false)
+                          listener: handleSwitchCaseNoWhenClause(fun)
+                          ensureColon(fun)
+                            rewriteAndRecover(fun, Message[ExpectedButGot, Expected ':' before this., null, {string: :}], :)
+                              reportRecoverableError((, Message[ExpectedButGot, Expected ':' before this., null, {string: :}])
+                                listener: handleRecoverableError(Message[ExpectedButGot, Expected ':' before this., null, {string: :}], (, ()
+                              rewriter()
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(()
+                          parseStatementsInSwitchCase(:, (, case, 0, 1, null, null)
+                            listener: beginSwitchCase(0, 1, case)
+                            parseStatement(:)
+                              parseStatementX(:)
+                                parseExpressionStatementOrDeclaration(:, null)
+                                  parseExpressionStatementOrDeclarationAfterModifiers(:, :, null, null, null, null)
+                                    looksLikeLocalFunction(()
+                                    parseExpressionStatement(:)
+                                      parseExpression(:)
+                                        looksLikeOuterPatternEquals(:)
+                                          skipOuterPattern(:)
+                                        parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                            parsePrimary(:, expression, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                                listener: handleNoTypeVariables(()
+                                                parseFunctionExpression(:)
+                                                  listener: beginFunctionExpression(()
+                                                  parseFormalParametersRequiredOpt(:, MemberKind.Local)
+                                                    parseFormalParametersRest((, MemberKind.Local)
+                                                      listener: beginFormalParameters((, MemberKind.Local)
+                                                      listener: endFormalParameters(0, (, ), MemberKind.Local)
+                                                  parseAsyncOptBody(), true, false)
+                                                    parseAsyncModifierOpt())
+                                                      listener: handleAsyncModifier(null, null)
+                                                      inPlainSync()
+                                                    parseFunctionBody(), true, false)
+                                                      listener: beginBlockFunctionBody({)
+                                                      notEofOrValue(}, })
+                                                      listener: endBlockFunctionBody(0, {, })
+                                                  listener: endFunctionExpression((, :)
+                                      ensureSemicolon(})
+                                        reportRecoverableError(}, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
+                                        rewriter()
+                                      listener: handleExpressionStatement(;)
+                            peekPastLabels(:)
+                            parseStatement(;)
+                              parseStatementX(;)
+                                parseExpressionStatementOrDeclaration(;, null)
+                                  parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, null)
+                                    looksLikeLocalFunction(:)
+                                    parseExpressionStatement(;)
+                                      parseExpression(;)
+                                        looksLikeOuterPatternEquals(;)
+                                          skipOuterPattern(;)
+                                        parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(;, true, ConstantPatternContext.none)
+                                            parsePrimary(;, expression, ConstantPatternContext.none)
+                                              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(, :)
+                                      ensureSemicolon()
+                                        reportRecoverableError(}, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
+                                          listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, })
+                                        rewriter()
+                                      listener: handleExpressionStatement(;)
+                            reportRecoverableError(:, Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}])
+                              listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token ':'., null, {lexeme: :}], :, :)
+                            peekPastLabels(case)
+                            listener: endSwitchCase(0, 1, null, null, 2, case, case)
+                          notEofOrValue(}, case)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    inPlainSync()
+                                    parseAssert(case, Assert.Expression)
+                                      listener: beginAssert(assert, Assert.Expression)
+                                      parseExpression(()
+                                        looksLikeOuterPatternEquals(()
+                                          skipOuterPattern(()
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
+                                              parseLiteralBool(()
+                                                listener: handleLiteralBool(false)
+                                      reportRecoverableError(assert, AssertAsExpression)
+                                        listener: handleRecoverableError(AssertAsExpression, assert, assert)
+                                      listener: endAssert(assert, Assert.Expression, (, null, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    inPlainSync()
+                                    parseSwitchExpression(case)
+                                      listener: beginSwitchExpression(switch)
+                                      ensureParenthesizedCondition(switch, allowCase: false)
+                                        parseExpressionInParenthesisRest((, allowCase: false)
+                                          parseExpression(()
+                                            looksLikeOuterPatternEquals(()
+                                              skipOuterPattern(()
+                                                skipObjectPatternRest(o)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
+                                                  parseSendOrFunctionLiteral((, expression)
+                                                    parseSend((, expression)
+                                                      isNextIdentifier(()
+                                                      ensureIdentifier((, expression)
+                                                        listener: handleIdentifier(o, expression)
+                                                      listener: handleNoTypeArguments())
+                                                      parseArgumentsOpt(o)
+                                                        listener: handleNoArguments())
+                                                      listener: handleSend(o, ))
+                                          ensureCloseParen(o, ()
+                                          listener: handleParenthesizedCondition((, null, null)
+                                      ensureBlock(), null, switch expression)
+                                      listener: beginSwitchExpressionBlock({)
+                                      listener: beginSwitchExpressionCase()
+                                      parsePattern({, PatternContext.matching, precedence: 1)
+                                        parsePrimaryPattern({, PatternContext.matching)
+                                          parseVariablePattern({, PatternContext.matching, typeInfo: Instance of 'NoType')
+                                            listener: handleNoType({)
+                                            listener: handleVariablePattern(null, _, false)
+                                      listener: handleSwitchExpressionCasePattern(_)
+                                      ensureFunctionArrow(_)
+                                      parseExpression(=>)
+                                        looksLikeOuterPatternEquals(=>)
+                                          skipOuterPattern(=>)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
+                                              parseLiteralBool(=>)
+                                                listener: handleLiteralBool(true)
+                                      listener: endSwitchExpressionCase(null, =>, true)
+                                      listener: endSwitchExpressionBlock(1, {, })
+                                      listener: endSwitchExpression(switch, })
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(})
+                          ensureColon(})
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  inPlainSync()
+                                  parseAwaitExpression(case, false)
+                                    listener: beginAwaitExpression(await)
+                                    parsePrecedenceExpression(await, 16, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(await, false, ConstantPatternContext.none)
+                                        parsePrimary(await, expression, ConstantPatternContext.none)
+                                          parseLiteralInt(await)
+                                            listener: handleLiteralInt(0)
+                                    inAsync()
+                                    listener: endAwaitExpression(await, :)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(0)
+                          ensureColon(0)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  reportRecoverableError(!, Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}])
+                                    listener: handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ! is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: !}], !, !)
+                                  parsePrecedenceExpression(!, 16, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(!, false, ConstantPatternContext.none)
+                                      parsePrimary(!, expression, ConstantPatternContext.none)
+                                        parseLiteralBool(!)
+                                          listener: handleLiteralBool(false)
+                                  listener: handleUnaryPrefixExpression(!)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(false)
+                          ensureColon(false)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  reportRecoverableError(~, Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}])
+                                    listener: handleRecoverableError(Message[InvalidConstantPatternUnary, The unary operator ~ is not supported as a constant pattern., Try wrapping the expression in 'const ( ... )'., {name: ~}], ~, ~)
+                                  parsePrecedenceExpression(~, 16, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(~, false, ConstantPatternContext.none)
+                                      parsePrimary(~, expression, ConstantPatternContext.none)
+                                        parseLiteralInt(~)
+                                          listener: handleLiteralInt(0)
+                                  listener: handleUnaryPrefixExpression(~)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(0)
+                          ensureColon(0)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrecedenceExpression(++, 16, false, ConstantPatternContext.none)
+                                    parseUnaryExpression(++, false, ConstantPatternContext.none)
+                                      parsePrimary(++, expression, ConstantPatternContext.none)
+                                        parseSendOrFunctionLiteral(++, expression)
+                                          parseSend(++, expression)
+                                            isNextIdentifier(++)
+                                            ensureIdentifier(++, expression)
+                                              listener: handleIdentifier(variable, expression)
+                                            listener: handleNoTypeArguments(:)
+                                            parseArgumentsOpt(variable)
+                                              listener: handleNoArguments(:)
+                                            listener: handleSend(variable, :)
+                                  listener: handleUnaryPrefixAssignmentExpression(++)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(variable)
+                          ensureColon(variable)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseSendOrFunctionLiteral(const, expression)
+                                      looksLikeFunctionBody(:)
+                                      parseSend(const, expression)
+                                        isNextIdentifier(const)
+                                        ensureIdentifier(const, expression)
+                                          listener: handleIdentifier(Class, expression)
+                                        listener: handleNoTypeArguments(()
+                                        parseArgumentsOpt(Class)
+                                          parseArguments(Class)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              listener: endArguments(0, (, ))
+                                        listener: handleSend(Class, :)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseSendOrFunctionLiteral(const, expression)
+                                      looksLikeFunctionBody(:)
+                                      parseSend(const, expression)
+                                        isNextIdentifier(const)
+                                        ensureIdentifier(const, expression)
+                                          listener: handleIdentifier(Class, expression)
+                                        listener: handleNoTypeArguments(()
+                                        parseArgumentsOpt(Class)
+                                          parseArguments(Class)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              parseExpression(()
+                                                looksLikeOuterPatternEquals(()
+                                                  skipOuterPattern(()
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
+                                                      parseLiteralInt(()
+                                                        listener: handleLiteralInt(0)
+                                              listener: endArguments(1, (, ))
+                                        listener: handleSend(Class, :)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseSendOrFunctionLiteral(const, expression)
+                                      looksLikeFunctionBody(:)
+                                      parseSend(const, expression)
+                                        isNextIdentifier(const)
+                                        ensureIdentifier(const, expression)
+                                          listener: handleIdentifier(GenericClass, expression)
+                                        listener: handleNoTypeArguments(()
+                                        parseArgumentsOpt(GenericClass)
+                                          parseArguments(GenericClass)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              listener: endArguments(0, (, ))
+                                        listener: handleSend(GenericClass, :)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseSendOrFunctionLiteral(const, expression)
+                                      looksLikeFunctionBody(:)
+                                      parseSend(const, expression)
+                                        isNextIdentifier(const)
+                                        ensureIdentifier(const, expression)
+                                          listener: handleIdentifier(GenericClass, expression)
+                                        listener: handleNoTypeArguments(()
+                                        parseArgumentsOpt(GenericClass)
+                                          parseArguments(GenericClass)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              ensureIdentifier((, namedArgumentReference)
+                                                listener: handleIdentifier(a, namedArgumentReference)
+                                              parseExpression(:)
+                                                looksLikeOuterPatternEquals(:)
+                                                  skipOuterPattern(:)
+                                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                                      parseLiteralInt(:)
+                                                        listener: handleLiteralInt(0)
+                                              listener: handleNamedArgument(:)
+                                              listener: endArguments(1, (, ))
+                                        listener: handleSend(GenericClass, :)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseSendOrFunctionLiteral(const, expression)
+                                      looksLikeFunctionBody(:)
+                                      parseSend(const, expression)
+                                        isNextIdentifier(const)
+                                        ensureIdentifier(const, expression)
+                                          listener: handleIdentifier(GenericClass, expression)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(int, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(int, null)
+                                        listener: endTypeArguments(1, <, >)
+                                        parseArgumentsOpt(>)
+                                          parseArguments(>)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              listener: endArguments(0, (, ))
+                                        listener: handleSend(GenericClass, :)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseSendOrFunctionLiteral(const, expression)
+                                      looksLikeFunctionBody(:)
+                                      parseSend(const, expression)
+                                        isNextIdentifier(const)
+                                        ensureIdentifier(const, expression)
+                                          listener: handleIdentifier(GenericClass, expression)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(int, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(int, null)
+                                        listener: endTypeArguments(1, <, >)
+                                        parseArgumentsOpt(>)
+                                          parseArguments(>)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              ensureIdentifier((, namedArgumentReference)
+                                                listener: handleIdentifier(a, namedArgumentReference)
+                                              parseExpression(:)
+                                                looksLikeOuterPatternEquals(:)
+                                                  skipOuterPattern(:)
+                                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                                      parseLiteralInt(:)
+                                                        listener: handleLiteralInt(0)
+                                              listener: handleNamedArgument(:)
+                                              listener: endArguments(1, (, ))
+                                        listener: handleSend(GenericClass, :)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parseImplicitCreationExpression(const, <, Instance of 'SimpleTypeArgument1')
+                                    listener: beginImplicitCreationExpression(GenericClass)
+                                    parseConstructorReference(const, ConstructorReferenceContext.Implicit, Instance of 'SimpleTypeArgument1')
+                                      ensureIdentifier(const, constructorReference)
+                                        listener: handleIdentifier(GenericClass, constructorReference)
+                                      listener: beginConstructorReference(GenericClass)
+                                      parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
+                                      listener: beginTypeArguments(<)
+                                      listener: handleIdentifier(int, typeReference)
+                                      listener: handleNoTypeArguments(>)
+                                      listener: handleType(int, null)
+                                      listener: endTypeArguments(1, <, >)
+                                      ensureIdentifier(., constructorReferenceContinuationAfterTypeArguments)
+                                        rewriter()
+                                        listener: handleNewAsIdentifier(new)
+                                        listener: handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
+                                      listener: endConstructorReference(GenericClass, ., (, ConstructorReferenceContext.Implicit)
+                                    parseConstructorInvocationArguments(new)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        listener: endArguments(0, (, ))
+                                    listener: endImplicitCreationExpression(GenericClass, <)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parseImplicitCreationExpression(const, <, Instance of 'SimpleTypeArgument1')
+                                    listener: beginImplicitCreationExpression(GenericClass)
+                                    parseConstructorReference(const, ConstructorReferenceContext.Implicit, Instance of 'SimpleTypeArgument1')
+                                      ensureIdentifier(const, constructorReference)
+                                        listener: handleIdentifier(GenericClass, constructorReference)
+                                      listener: beginConstructorReference(GenericClass)
+                                      parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
+                                      listener: beginTypeArguments(<)
+                                      listener: handleIdentifier(int, typeReference)
+                                      listener: handleNoTypeArguments(>)
+                                      listener: handleType(int, null)
+                                      listener: endTypeArguments(1, <, >)
+                                      ensureIdentifier(., constructorReferenceContinuationAfterTypeArguments)
+                                        rewriter()
+                                        listener: handleNewAsIdentifier(new)
+                                        listener: handleIdentifier(new, constructorReferenceContinuationAfterTypeArguments)
+                                      listener: endConstructorReference(GenericClass, ., (, ConstructorReferenceContext.Implicit)
+                                    parseConstructorInvocationArguments(new)
+                                      parseArgumentsRest(()
+                                        listener: beginArguments(()
+                                        ensureIdentifier((, namedArgumentReference)
+                                          listener: handleIdentifier(a, namedArgumentReference)
+                                        parseExpression(:)
+                                          looksLikeOuterPatternEquals(:)
+                                            skipOuterPattern(:)
+                                          parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                              parsePrimary(:, expression, ConstantPatternContext.none)
+                                                parseLiteralInt(:)
+                                                  listener: handleLiteralInt(1)
+                                        listener: handleNamedArgument(:)
+                                        listener: endArguments(1, (, ))
+                                    listener: endImplicitCreationExpression(GenericClass, <)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    listener: handleNoTypeArguments([])
+                                    parseLiteralListSuffix(const, null)
+                                      rewriteSquareBrackets(const)
+                                        link([, ])
+                                        rewriter()
+                                      listener: handleLiteralList(0, [, null, ])
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(])
+                          ensureColon(])
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseLiteralListSetMapOrFunction(const, null)
+                                      listener: beginTypeArguments(<)
+                                      listener: handleIdentifier(int, typeReference)
+                                      listener: handleNoTypeArguments(>)
+                                      listener: handleType(int, null)
+                                      listener: endTypeArguments(1, <, >)
+                                      parseLiteralListSuffix(>, null)
+                                        rewriteSquareBrackets(>)
+                                          link([, ])
+                                          rewriter()
+                                        listener: handleLiteralList(0, [, null, ])
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(])
+                          ensureColon(])
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    listener: handleNoTypeArguments({)
+                                    parseLiteralSetOrMapSuffix(const, null)
+                                      listener: handleLiteralSetOrMap(0, {, null, }, false)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(})
+                          ensureColon(})
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseLiteralListSetMapOrFunction(const, null)
+                                      listener: beginTypeArguments(<)
+                                      listener: handleIdentifier(int, typeReference)
+                                      listener: handleNoTypeArguments(,)
+                                      listener: handleType(int, null)
+                                      listener: handleIdentifier(String, typeReference)
+                                      listener: handleNoTypeArguments(>)
+                                      listener: handleType(String, null)
+                                      listener: endTypeArguments(2, <, >)
+                                      parseLiteralSetOrMapSuffix(>, null)
+                                        listener: handleLiteralSetOrMap(0, {, null, }, false)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(})
+                          ensureColon(})
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstExpression(const)
+                                      parseConstructorReference(const, ConstructorReferenceContext.Const, null)
+                                        ensureIdentifier(const, constructorReference)
+                                          listener: handleIdentifier(Class, constructorReference)
+                                        listener: beginConstructorReference(Class)
+                                        parseQualifiedRestOpt(Class, constructorReferenceContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(Class, null, (, ConstructorReferenceContext.Const)
+                                      parseConstructorInvocationArguments(Class)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: endConstExpression(const)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstExpression(const)
+                                      parseConstructorReference(const, ConstructorReferenceContext.Const, null)
+                                        ensureIdentifier(const, constructorReference)
+                                          listener: handleIdentifier(Class, constructorReference)
+                                        listener: beginConstructorReference(Class)
+                                        parseQualifiedRestOpt(Class, constructorReferenceContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(Class, null, (, ConstructorReferenceContext.Const)
+                                      parseConstructorInvocationArguments(Class)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          parseExpression(()
+                                            looksLikeOuterPatternEquals(()
+                                              skipOuterPattern(()
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
+                                                  parseLiteralInt(()
+                                                    listener: handleLiteralInt(0)
+                                          listener: endArguments(1, (, ))
+                                      listener: endConstExpression(const)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstExpression(const)
+                                      parseConstructorReference(const, ConstructorReferenceContext.Const, null)
+                                        ensureIdentifier(const, constructorReference)
+                                          listener: handleIdentifier(GenericClass, constructorReference)
+                                        listener: beginConstructorReference(GenericClass)
+                                        parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                                      parseConstructorInvocationArguments(GenericClass)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: endConstExpression(const)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstExpression(const)
+                                      parseConstructorReference(const, ConstructorReferenceContext.Const, null)
+                                        ensureIdentifier(const, constructorReference)
+                                          listener: handleIdentifier(GenericClass, constructorReference)
+                                        listener: beginConstructorReference(GenericClass)
+                                        parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                                      parseConstructorInvocationArguments(GenericClass)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          ensureIdentifier((, namedArgumentReference)
+                                            listener: handleIdentifier(a, namedArgumentReference)
+                                          parseExpression(:)
+                                            looksLikeOuterPatternEquals(:)
+                                              skipOuterPattern(:)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
+                                                  parseLiteralInt(:)
+                                                    listener: handleLiteralInt(0)
+                                          listener: handleNamedArgument(:)
+                                          listener: endArguments(1, (, ))
+                                      listener: endConstExpression(const)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstExpression(const)
+                                      parseConstructorReference(const, ConstructorReferenceContext.Const, null)
+                                        ensureIdentifier(const, constructorReference)
+                                          listener: handleIdentifier(GenericClass, constructorReference)
+                                        listener: beginConstructorReference(GenericClass)
+                                        parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(int, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(int, null)
+                                        listener: endTypeArguments(1, <, >)
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                                      parseConstructorInvocationArguments(>)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: endConstExpression(const)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstExpression(const)
+                                      parseConstructorReference(const, ConstructorReferenceContext.Const, null)
+                                        ensureIdentifier(const, constructorReference)
+                                          listener: handleIdentifier(GenericClass, constructorReference)
+                                        listener: beginConstructorReference(GenericClass)
+                                        parseQualifiedRestOpt(GenericClass, constructorReferenceContinuation)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(int, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(int, null)
+                                        listener: endTypeArguments(1, <, >)
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(GenericClass, null, (, ConstructorReferenceContext.Const)
+                                      parseConstructorInvocationArguments(>)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          ensureIdentifier((, namedArgumentReference)
+                                            listener: handleIdentifier(a, namedArgumentReference)
+                                          parseExpression(:)
+                                            looksLikeOuterPatternEquals(:)
+                                              skipOuterPattern(:)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
+                                                  parseLiteralInt(:)
+                                                    listener: handleLiteralInt(0)
+                                          listener: handleNamedArgument(:)
+                                          listener: endArguments(1, (, ))
+                                      listener: endConstExpression(const)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstLiteral([])
+                                      listener: handleNoTypeArguments([])
+                                      parseLiteralListSuffix(const, const)
+                                        rewriteSquareBrackets(const)
+                                          link([, ])
+                                          rewriter()
+                                        listener: handleLiteralList(0, [, const, ])
+                                      listener: endConstLiteral(:)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(])
+                          ensureColon(])
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstLiteral(<)
+                                      parseLiteralListSetMapOrFunction(const, const)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(int, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(int, null)
+                                        listener: endTypeArguments(1, <, >)
+                                        parseLiteralListSuffix(>, const)
+                                          rewriteSquareBrackets(>)
+                                            link([, ])
+                                            rewriter()
+                                          listener: handleLiteralList(0, [, const, ])
+                                      listener: endConstLiteral(:)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(])
+                          ensureColon(])
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstLiteral({)
+                                      listener: handleNoTypeArguments({)
+                                      parseLiteralSetOrMapSuffix(const, const)
+                                        listener: handleLiteralSetOrMap(0, {, const, }, false)
+                                      listener: endConstLiteral(:)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(})
+                          ensureColon(})
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstLiteral(<)
+                                      parseLiteralListSetMapOrFunction(const, const)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(int, typeReference)
+                                        listener: handleNoTypeArguments(,)
+                                        listener: handleType(int, null)
+                                        listener: handleIdentifier(String, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(String, null)
+                                        listener: endTypeArguments(2, <, >)
+                                        parseLiteralSetOrMapSuffix(>, const)
+                                          listener: handleLiteralSetOrMap(0, {, const, }, false)
+                                      listener: endConstLiteral(:)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause(})
+                          ensureColon(})
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseNewExpression(const)
+                                      isNextIdentifier(new)
+                                      listener: beginNewExpression(new)
+                                      parseConstructorReference(new, ConstructorReferenceContext.New, null)
+                                        ensureIdentifier(new, constructorReference)
+                                          listener: handleIdentifier(Class, constructorReference)
+                                        listener: beginConstructorReference(Class)
+                                        parseQualifiedRestOpt(Class, constructorReferenceContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(Class, null, (, ConstructorReferenceContext.New)
+                                      parseConstructorInvocationArguments(Class)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: endNewExpression(new)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseNewExpression(case)
+                                      isNextIdentifier(new)
+                                      listener: beginNewExpression(new)
+                                      parseConstructorReference(new, ConstructorReferenceContext.New, null)
+                                        ensureIdentifier(new, constructorReference)
+                                          listener: handleIdentifier(Class, constructorReference)
+                                        listener: beginConstructorReference(Class)
+                                        parseQualifiedRestOpt(Class, constructorReferenceContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        listener: handleNoConstructorReferenceContinuationAfterTypeArguments(()
+                                        listener: endConstructorReference(Class, null, (, ConstructorReferenceContext.New)
+                                      parseConstructorInvocationArguments(Class)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                      listener: endNewExpression(new)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        ensureCloseParen((, ()
+                                        reportRecoverableError(), InvalidConstantPatternEmptyRecordLiteral)
+                                          listener: handleRecoverableError(InvalidConstantPatternEmptyRecordLiteral, ), ))
+                                        listener: endRecordLiteral((, 0, null)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    reportRecoverableError(const, InvalidConstantPatternDuplicateConst)
+                                      listener: handleRecoverableError(InvalidConstantPatternDuplicateConst, const, const)
+                                    parseConstExpression(const)
+                                      listener: beginConstLiteral(()
+                                      parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        ensureCloseParen((, ()
+                                        listener: endRecordLiteral((, 0, const)
+                                      listener: endConstLiteral(:)
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseLiteralInt(()
+                                                  listener: handleLiteralInt(1)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
+                                                    parseLiteralInt(-)
+                                                      listener: handleLiteralInt(1)
+                                              listener: handleUnaryPrefixExpression(-)
+                                        ensureCloseParen(1, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                              skipObjectPatternRest(value)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(value, expression)
+                                                    listener: handleNoTypeArguments())
+                                                    parseArgumentsOpt(value)
+                                                      listener: handleNoArguments())
+                                                    listener: handleSend(value, ))
+                                        ensureCloseParen(value, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                  parsePrimary(-, expression, ConstantPatternContext.none)
+                                                    parseSendOrFunctionLiteral(-, expression)
+                                                      parseSend(-, expression)
+                                                        isNextIdentifier(-)
+                                                        ensureIdentifier(-, expression)
+                                                          listener: handleIdentifier(value, expression)
+                                                        listener: handleNoTypeArguments())
+                                                        parseArgumentsOpt(value)
+                                                          listener: handleNoArguments())
+                                                        listener: handleSend(value, ))
+                                              listener: handleUnaryPrefixExpression(-)
+                                        ensureCloseParen(value, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseLiteralInt(()
+                                                  listener: handleLiteralInt(1)
+                                            listener: beginBinaryExpression(+)
+                                            parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                                parsePrimary(+, expression, ConstantPatternContext.none)
+                                                  parseLiteralInt(+)
+                                                    listener: handleLiteralInt(2)
+                                            listener: endBinaryExpression(+)
+                                        ensureCloseParen(2, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(GenericClass, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(GenericClass)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(GenericClass, <)
+                                listener: beginTypeArguments(<)
+                                listener: handleIdentifier(int, typeReference)
+                                listener: handleNoTypeArguments(>)
+                                listener: handleType(int, null)
+                                listener: endTypeArguments(1, <, >)
+                                reportRecoverableError(<, InvalidConstantPatternGeneric)
+                                  listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                                listener: handleTypeArgumentApplication(<)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(>)
+                          ensureColon(>)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(prefix, expression)
+                                        listener: handleNoTypeArguments(.)
+                                        parseArgumentsOpt(prefix)
+                                          listener: handleNoArguments(.)
+                                        listener: handleSend(prefix, .)
+                                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                  parseSendOrFunctionLiteral(., expressionContinuation)
+                                    parseSend(., expressionContinuation)
+                                      isNextIdentifier(.)
+                                      ensureIdentifier(., expressionContinuation)
+                                        listener: handleIdentifier(GenericClass, expressionContinuation)
+                                      listener: handleNoTypeArguments(<)
+                                      parseArgumentsOpt(GenericClass)
+                                        listener: handleNoArguments(<)
+                                      listener: handleSend(GenericClass, <)
+                                listener: handleEndingBinaryExpression(.)
+                                listener: beginTypeArguments(<)
+                                listener: handleIdentifier(int, typeReference)
+                                listener: handleNoTypeArguments(>)
+                                listener: handleType(int, null)
+                                listener: endTypeArguments(1, <, >)
+                                reportRecoverableError(<, InvalidConstantPatternGeneric)
+                                  listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                                listener: handleTypeArgumentApplication(<)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(>)
+                          ensureColon(>)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(GenericClass, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(GenericClass)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(GenericClass, <)
+                                listener: beginTypeArguments(<)
+                                listener: handleIdentifier(int, typeReference)
+                                listener: handleNoTypeArguments(>)
+                                listener: handleType(int, null)
+                                listener: endTypeArguments(1, <, >)
+                                reportRecoverableError(<, InvalidConstantPatternGeneric)
+                                  listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                                listener: handleTypeArgumentApplication(<)
+                                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                  rewriter()
+                                  listener: handleNewAsIdentifier(new)
+                                  parseSendOrFunctionLiteral(., expressionContinuation)
+                                    parseSend(., expressionContinuation)
+                                      isNextIdentifier(.)
+                                      ensureIdentifier(., expressionContinuation)
+                                        listener: handleIdentifier(new, expressionContinuation)
+                                      listener: handleNoTypeArguments(:)
+                                      parseArgumentsOpt(new)
+                                        listener: handleNoArguments(:)
+                                      listener: handleSend(new, :)
+                                listener: handleEndingBinaryExpression(.)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(new)
+                          ensureColon(new)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(null)
+                              parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                                parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                                  parsePrimary(case, expression, ConstantPatternContext.implicit)
+                                    parseSendOrFunctionLiteral(case, expression)
+                                      parseSend(case, expression)
+                                        isNextIdentifier(case)
+                                        ensureIdentifier(case, expression)
+                                          listener: handleIdentifier(prefix, expression)
+                                        listener: handleNoTypeArguments(.)
+                                        parseArgumentsOpt(prefix)
+                                          listener: handleNoArguments(.)
+                                        listener: handleSend(prefix, .)
+                                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                  parseSendOrFunctionLiteral(., expressionContinuation)
+                                    parseSend(., expressionContinuation)
+                                      isNextIdentifier(.)
+                                      ensureIdentifier(., expressionContinuation)
+                                        listener: handleIdentifier(GenericClass, expressionContinuation)
+                                      listener: handleNoTypeArguments(<)
+                                      parseArgumentsOpt(GenericClass)
+                                        listener: handleNoArguments(<)
+                                      listener: handleSend(GenericClass, <)
+                                listener: handleEndingBinaryExpression(.)
+                                listener: beginTypeArguments(<)
+                                listener: handleIdentifier(int, typeReference)
+                                listener: handleNoTypeArguments(>)
+                                listener: handleType(int, null)
+                                listener: endTypeArguments(1, <, >)
+                                reportRecoverableError(<, InvalidConstantPatternGeneric)
+                                  listener: handleRecoverableError(InvalidConstantPatternGeneric, <, <)
+                                listener: handleTypeArgumentApplication(<)
+                                parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                  rewriter()
+                                  listener: handleNewAsIdentifier(new)
+                                  parseSendOrFunctionLiteral(., expressionContinuation)
+                                    parseSend(., expressionContinuation)
+                                      isNextIdentifier(.)
+                                      ensureIdentifier(., expressionContinuation)
+                                        listener: handleIdentifier(new, expressionContinuation)
+                                      listener: handleNoTypeArguments(:)
+                                      parseArgumentsOpt(new)
+                                        listener: handleNoArguments(:)
+                                      listener: handleSend(new, :)
+                                listener: handleEndingBinaryExpression(.)
+                              listener: endConstantPattern(null)
+                          listener: handleSwitchCaseNoWhenClause(new)
+                          ensureColon(new)
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                              skipObjectPatternRest(GenericClass)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(GenericClass, expression)
+                                                    listener: handleNoTypeArguments(<)
+                                                    parseArgumentsOpt(GenericClass)
+                                                      listener: handleNoArguments(<)
+                                                    listener: handleSend(GenericClass, <)
+                                            listener: beginTypeArguments(<)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(>)
+                                            listener: handleType(int, null)
+                                            listener: endTypeArguments(1, <, >)
+                                            listener: handleTypeArgumentApplication(<)
+                                        ensureCloseParen(>, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                              skipObjectPatternRest(GenericClass)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(prefix, expression)
+                                                    listener: handleNoTypeArguments(.)
+                                                    parseArgumentsOpt(prefix)
+                                                      listener: handleNoArguments(.)
+                                                    listener: handleSend(prefix, .)
+                                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                                parseSend(., expressionContinuation)
+                                                  isNextIdentifier(.)
+                                                  ensureIdentifier(., expressionContinuation)
+                                                    listener: handleIdentifier(GenericClass, expressionContinuation)
+                                                  listener: handleNoTypeArguments(<)
+                                                  parseArgumentsOpt(GenericClass)
+                                                    listener: handleNoArguments(<)
+                                                  listener: handleSend(GenericClass, <)
+                                            listener: handleEndingBinaryExpression(.)
+                                            listener: beginTypeArguments(<)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(>)
+                                            listener: handleType(int, null)
+                                            listener: endTypeArguments(1, <, >)
+                                            listener: handleTypeArgumentApplication(<)
+                                        ensureCloseParen(>, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                              skipObjectPatternRest(GenericClass)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(GenericClass, expression)
+                                                    listener: handleNoTypeArguments(<)
+                                                    parseArgumentsOpt(GenericClass)
+                                                      listener: handleNoArguments(<)
+                                                    listener: handleSend(GenericClass, <)
+                                            listener: beginTypeArguments(<)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(>)
+                                            listener: handleType(int, null)
+                                            listener: endTypeArguments(1, <, >)
+                                            listener: handleTypeArgumentApplication(<)
+                                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                              rewriter()
+                                              listener: handleNewAsIdentifier(new)
+                                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                                parseSend(., expressionContinuation)
+                                                  isNextIdentifier(.)
+                                                  ensureIdentifier(., expressionContinuation)
+                                                    listener: handleIdentifier(new, expressionContinuation)
+                                                  listener: handleNoTypeArguments())
+                                                  parseArgumentsOpt(new)
+                                                    listener: handleNoArguments())
+                                                  listener: handleSend(new, ))
+                                            listener: handleEndingBinaryExpression(.)
+                                        ensureCloseParen(new, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(case)
+                          listener: beginCaseExpression(case)
+                          parsePattern(case, PatternContext.matching, precedence: 1)
+                            parsePrimaryPattern(case, PatternContext.matching)
+                              listener: beginConstantPattern(const)
+                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                      parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
+                                        listener: beginParenthesizedExpressionOrRecordLiteral(()
+                                        parseExpression(()
+                                          looksLikeOuterPatternEquals(()
+                                            skipOuterPattern(()
+                                              skipObjectPatternRest(GenericClass)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
+                                                parseSendOrFunctionLiteral((, expression)
+                                                  parseSend((, expression)
+                                                    isNextIdentifier(()
+                                                    ensureIdentifier((, expression)
+                                                      listener: handleIdentifier(prefix, expression)
+                                                    listener: handleNoTypeArguments(.)
+                                                    parseArgumentsOpt(prefix)
+                                                      listener: handleNoArguments(.)
+                                                    listener: handleSend(prefix, .)
+                                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                                parseSend(., expressionContinuation)
+                                                  isNextIdentifier(.)
+                                                  ensureIdentifier(., expressionContinuation)
+                                                    listener: handleIdentifier(GenericClass, expressionContinuation)
+                                                  listener: handleNoTypeArguments(<)
+                                                  parseArgumentsOpt(GenericClass)
+                                                    listener: handleNoArguments(<)
+                                                  listener: handleSend(GenericClass, <)
+                                            listener: handleEndingBinaryExpression(.)
+                                            listener: beginTypeArguments(<)
+                                            listener: handleIdentifier(int, typeReference)
+                                            listener: handleNoTypeArguments(>)
+                                            listener: handleType(int, null)
+                                            listener: endTypeArguments(1, <, >)
+                                            listener: handleTypeArgumentApplication(<)
+                                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
+                                              rewriter()
+                                              listener: handleNewAsIdentifier(new)
+                                              parseSendOrFunctionLiteral(., expressionContinuation)
+                                                parseSend(., expressionContinuation)
+                                                  isNextIdentifier(.)
+                                                  ensureIdentifier(., expressionContinuation)
+                                                    listener: handleIdentifier(new, expressionContinuation)
+                                                  listener: handleNoTypeArguments())
+                                                  parseArgumentsOpt(new)
+                                                    listener: handleNoArguments())
+                                                  listener: handleSend(new, ))
+                                            listener: handleEndingBinaryExpression(.)
+                                        ensureCloseParen(new, ()
+                                        listener: endParenthesizedExpression(()
+                              listener: endConstantPattern(const)
+                          listener: handleSwitchCaseNoWhenClause())
+                          ensureColon())
+                          listener: endCaseExpression(case, null, :)
+                          peekPastLabels(print)
+                          parseStatementsInSwitchCase(:, print, case, 0, 45, null, null)
+                            listener: beginSwitchCase(0, 45, case)
+                            parseStatement(:)
+                              parseStatementX(:)
+                                parseExpressionStatementOrDeclarationAfterModifiers(:, :, null, null, null, null)
+                                  looksLikeLocalFunction(print)
+                                  parseExpressionStatement(:)
+                                    parseExpression(:)
+                                      looksLikeOuterPatternEquals(:)
+                                        skipOuterPattern(:)
+                                          skipObjectPatternRest(print)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
+                                            parseSendOrFunctionLiteral(:, expression)
+                                              looksLikeFunctionBody(;)
+                                              parseSend(:, expression)
+                                                isNextIdentifier(:)
+                                                ensureIdentifier(:, expression)
+                                                  listener: handleIdentifier(print, expression)
+                                                listener: handleNoTypeArguments(()
+                                                parseArgumentsOpt(print)
+                                                  parseArguments(print)
+                                                    parseArgumentsRest(()
+                                                      listener: beginArguments(()
+                                                      parseExpression(()
+                                                        looksLikeOuterPatternEquals(()
+                                                          skipOuterPattern(()
+                                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                            parsePrimary((, expression, ConstantPatternContext.none)
+                                                              parseLiteralInt(()
+                                                                listener: handleLiteralInt(0)
+                                                      listener: endArguments(1, (, ))
+                                                listener: handleSend(print, ;)
+                                    ensureSemicolon())
+                                    listener: handleExpressionStatement(;)
+                            peekPastLabels(})
+                            listener: endSwitchCase(0, 45, null, null, 1, case, })
+                          notEofOrValue(}, })
+                          listener: endSwitchBlock(4, {, })
+                        listener: endSwitchStatement(switch, })
+                  notEofOrValue(}, })
+                  listener: endBlockFunctionBody(3, {, })
+                listener: endClassMethod(null, test, (, null, })
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 3, {, })
+          listener: endClassDeclaration(class, })
+  listener: endTopLevelDeclaration(class)
+  parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext')
+    parseMetadataStar(})
+      listener: beginMetadataStar(class)
+      listener: endMetadataStar(0)
+    parseTopLevelKeywordDeclaration(}, class, null, null, null, null, null, Instance of 'DirectiveContext')
+      parseClassOrNamedMixinApplication(null, null, null, null, null, null, null, null, null, class)
+        listener: beginClassOrMixinOrNamedMixinApplicationPrelude(class)
+        ensureIdentifier(class, classOrMixinDeclaration)
+          listener: handleIdentifier(GenericClass, classOrMixinDeclaration)
+        listener: beginTypeVariables(<)
+        listener: beginMetadataStar(T)
+        listener: endMetadataStar(0)
+        listener: handleIdentifier(T, typeVariableDeclaration)
+        listener: beginTypeVariable(T)
+        listener: handleTypeVariablesDefined(T, 1)
+        listener: handleNoType(T)
+        listener: endTypeVariable(>, 0, null, null)
+        listener: endTypeVariables(<, >)
+        listener: beginClassDeclaration(class, null, null, null, null, null, null, null, null, null, GenericClass)
+        parseClass(>, class, class, GenericClass)
+          parseClassHeaderOpt(>, class, class)
+            parseClassExtendsOpt(>)
+              listener: handleNoType(>)
+              listener: handleClassExtends(null, 1)
+            parseClassWithClauseOpt(>)
+              listener: handleClassNoWithClause()
+            parseClassOrMixinOrEnumImplementsOpt(>)
+              listener: handleImplements(null, 0)
+            listener: handleClassHeader(class, class, null)
+          parseClassOrMixinOrExtensionBody(>, DeclarationKind.Class, GenericClass)
+            listener: beginClassOrMixinOrExtensionBody(DeclarationKind.Class, {)
+            notEofOrValue(}, const)
+            parseClassOrMixinOrExtensionOrEnumMemberImpl({, DeclarationKind.Class, GenericClass)
+              parseMetadataStar({)
+                listener: beginMetadataStar(const)
+                listener: endMetadataStar(0)
+              listener: beginMember()
+              parseMethod({, null, null, null, null, null, null, const, const, Instance of 'NoType', null, GenericClass, DeclarationKind.Class, GenericClass, false)
+                listener: beginMethod(DeclarationKind.Class, null, null, null, null, const, null, GenericClass)
+                listener: handleNoType(const)
+                ensureIdentifierPotentiallyRecovered(const, methodDeclaration, false)
+                  listener: handleIdentifier(GenericClass, methodDeclaration)
+                parseQualifiedRestOpt(GenericClass, methodDeclarationContinuation)
+                parseMethodTypeVar(GenericClass)
+                  listener: handleNoTypeVariables(()
+                parseGetterOrFormalParameters(GenericClass, GenericClass, false, MemberKind.NonStaticMethod)
+                  parseFormalParameters(GenericClass, MemberKind.NonStaticMethod)
+                    parseFormalParametersRest((, MemberKind.NonStaticMethod)
+                      listener: beginFormalParameters((, MemberKind.NonStaticMethod)
+                      parseOptionalNamedParameters((, MemberKind.NonStaticMethod)
+                        listener: beginOptionalFormalParameters({)
+                        parseFormalParameter({, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
+                          parseMetadataStar({)
+                            listener: beginMetadataStar(a)
+                            listener: endMetadataStar(0)
+                          listener: beginFormalParameter(a, MemberKind.NonStaticMethod, null, null, null)
+                          listener: handleNoType({)
+                          ensureIdentifier({, formalParameterDeclaration)
+                            listener: handleIdentifier(a, formalParameterDeclaration)
+                          listener: handleFormalParameterWithoutValue(})
+                          listener: endFormalParameter(null, null, null, a, null, null, FormalParameterKind.optionalNamed, MemberKind.NonStaticMethod)
+                        listener: endOptionalFormalParameters(1, {, })
+                      ensureCloseParen(}, ()
+                      listener: endFormalParameters(1, (, ), MemberKind.NonStaticMethod)
+                parseInitializersOpt())
+                  listener: handleNoInitializers()
+                parseAsyncModifierOpt())
+                  listener: handleAsyncModifier(null, null)
+                  inPlainSync()
+                inPlainSync()
+                parseFunctionBody(), false, true)
+                  listener: handleEmptyFunctionBody(;)
+                listener: endClassConstructor(null, const, (, null, ;)
+              listener: endMember()
+            notEofOrValue(}, })
+            listener: endClassOrMixinOrExtensionBody(DeclarationKind.Class, 1, {, })
+          listener: endClassDeclaration(class, })
+  listener: endTopLevelDeclaration()
+  reportAllErrorTokens(import)
+  listener: endCompilationUnit(5, )

pkg/front_end/parser_testcases/patterns/const_patterns.dart.parser.expect

diff --git a/pkg/front_end/parser_testcases/patterns/const_patterns.dart.parser.expect b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.parser.expect
new file mode 100644
index 0000000..4f4f414
--- /dev/null
+++ b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.parser.expect
@@ -0,0 +1,183 @@
+NOTICE: Stream was rewritten by parser!
+
+import 'const_patterns.dart' as prefix;
+
+const int value = 42;
+
+void func() {}
+
+class Class {
+const Class([a]);
+
+call() {}
+
+test(o) async {
+const dynamic local = 0;
+dynamic variable = 0;
+switch (o) {
+case true:
+case null:
+case this:
+case this():
+case super():
+case 42:
+case -42:
+case 42.5:
+case -42.5:
+case 'foo':
+case 'foo' 'bar':
+case value:
+case -value:
+case local:
+case -local:
+case func:
+case prefix.value:
+case -prefix.value:
+case 1 :*synthetic*+ 2;*synthetic*;:
+case 1 :*synthetic** 2;*synthetic*;:
+case void fun:() {};*synthetic*;:
+case assert(false):
+case switch (o) { _ => true }:
+case await 0:
+case !false:
+case ~0:
+case ++variable:
+case const Class():
+case const Class(0):
+case const GenericClass():
+case const GenericClass(a: 0):
+case const GenericClass<int>():
+case const GenericClass<int>(a: 0):
+case const GenericClass<int>.new():
+case const GenericClass<int>.new(a: 1):
+case const []:
+case const <int>[]:
+case const {}:
+case const <int, String>{}:
+case const const Class():
+case const const Class(0):
+case const const GenericClass():
+case const const GenericClass(a: 0):
+case const const GenericClass<int>():
+case const const GenericClass<int>(a: 0):
+case const const []:
+case const const <int>[]:
+case const const {}:
+case const const <int, String>{}:
+case const new Class():
+case new Class():
+case const ():
+case const const ():
+case const (1):
+case const (-1):
+case const (value):
+case const (-value):
+case const (1 + 2):
+case GenericClass<int>:
+case prefix.GenericClass<int>:
+case GenericClass<int>.new:
+case prefix.GenericClass<int>.new:
+case const (GenericClass<int>):
+case const (prefix.GenericClass<int>):
+case const (GenericClass<int>.new):
+case const (prefix.GenericClass<int>.new):
+print(0);
+}
+}
+}
+
+class GenericClass<T> {
+const GenericClass({a});
+}
+
+
+import[KeywordToken] 'const_patterns.dart'[StringToken] as[KeywordToken] prefix[StringToken];[SimpleToken]
+
+const[KeywordToken] int[StringToken] value[StringToken] =[SimpleToken] 42[StringToken];[SimpleToken]
+
+void[KeywordToken] func[StringToken]([BeginToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+
+class[KeywordToken] Class[StringToken] {[BeginToken]
+const[KeywordToken] Class[StringToken]([BeginToken][[BeginToken]a[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
+
+call[StringToken]([BeginToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+
+test[StringToken]([BeginToken]o[StringToken])[SimpleToken] async[KeywordToken] {[BeginToken]
+const[KeywordToken] dynamic[KeywordToken] local[StringToken] =[SimpleToken] 0[StringToken];[SimpleToken]
+dynamic[KeywordToken] variable[StringToken] =[SimpleToken] 0[StringToken];[SimpleToken]
+switch[KeywordToken] ([BeginToken]o[StringToken])[SimpleToken] {[BeginToken]
+case[KeywordToken] true[KeywordToken]:[SimpleToken]
+case[KeywordToken] null[KeywordToken]:[SimpleToken]
+case[KeywordToken] this[KeywordToken]:[SimpleToken]
+case[KeywordToken] this[KeywordToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] super[KeywordToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] 42[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]42[StringToken]:[SimpleToken]
+case[KeywordToken] 42.5[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]42.5[StringToken]:[SimpleToken]
+case[KeywordToken] 'foo'[StringToken]:[SimpleToken]
+case[KeywordToken] 'foo'[StringToken] 'bar'[StringToken]:[SimpleToken]
+case[KeywordToken] value[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]value[StringToken]:[SimpleToken]
+case[KeywordToken] local[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]local[StringToken]:[SimpleToken]
+case[KeywordToken] func[StringToken]:[SimpleToken]
+case[KeywordToken] prefix[StringToken].[SimpleToken]value[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]prefix[StringToken].[SimpleToken]value[StringToken]:[SimpleToken]
+case[KeywordToken] 1[StringToken] :[SyntheticToken][SyntheticStringToken]+[SimpleToken] 2[StringToken];[SyntheticToken][SyntheticStringToken];[SyntheticToken]:[SimpleToken]
+case[KeywordToken] 1[StringToken] :[SyntheticToken][SyntheticStringToken]*[SimpleToken] 2[StringToken];[SyntheticToken][SyntheticStringToken];[SyntheticToken]:[SimpleToken]
+case[KeywordToken] void[KeywordToken] fun[StringToken]:[SyntheticToken]([BeginToken])[SimpleToken] {[BeginToken]}[SimpleToken];[SyntheticToken][SyntheticStringToken];[SyntheticToken]:[SimpleToken]
+case[KeywordToken] assert[KeywordToken]([BeginToken]false[KeywordToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] switch[KeywordToken] ([BeginToken]o[StringToken])[SimpleToken] {[BeginToken] _[StringToken] =>[SimpleToken] true[KeywordToken] }[SimpleToken]:[SimpleToken]
+case[KeywordToken] await[KeywordToken] 0[StringToken]:[SimpleToken]
+case[KeywordToken] ![SimpleToken]false[KeywordToken]:[SimpleToken]
+case[KeywordToken] ~[SimpleToken]0[StringToken]:[SimpleToken]
+case[KeywordToken] ++[SimpleToken]variable[StringToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken]0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[StringToken]([BeginToken]a[StringToken]:[SimpleToken] 1[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] [[BeginToken]][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken]>[SimpleToken][[BeginToken]][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] {[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken],[SimpleToken] String[StringToken]>[SimpleToken]{[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken]0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] [[BeginToken]][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken]>[SimpleToken][[BeginToken]][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] {[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken],[SimpleToken] String[StringToken]>[SimpleToken]{[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] new[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] new[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] ([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]1[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]-[SimpleToken]1[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]value[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]-[SimpleToken]value[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]1[StringToken] +[SimpleToken] 2[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]:[SimpleToken]
+case[KeywordToken] prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]:[SimpleToken]
+case[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[StringToken]:[SimpleToken]
+case[KeywordToken] prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[StringToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[StringToken])[SimpleToken]:[SimpleToken]
+print[StringToken]([BeginToken]0[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+
+class[KeywordToken] GenericClass[StringToken]<[BeginToken]T[StringToken]>[SimpleToken] {[BeginToken]
+const[KeywordToken] GenericClass[StringToken]([BeginToken]{[BeginToken]a[StringToken]}[SimpleToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]

pkg/front_end/parser_testcases/patterns/const_patterns.dart.scanner.expect

diff --git a/pkg/front_end/parser_testcases/patterns/const_patterns.dart.scanner.expect b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.scanner.expect
new file mode 100644
index 0000000..5ac5422
--- /dev/null
+++ b/pkg/front_end/parser_testcases/patterns/const_patterns.dart.scanner.expect
@@ -0,0 +1,181 @@
+import 'const_patterns.dart' as prefix;
+
+const int value = 42;
+
+void func() {}
+
+class Class {
+const Class([a]);
+
+call() {}
+
+test(o) async {
+const dynamic local = 0;
+dynamic variable = 0;
+switch (o) {
+case true:
+case null:
+case this:
+case this():
+case super():
+case 42:
+case -42:
+case 42.5:
+case -42.5:
+case 'foo':
+case 'foo' 'bar':
+case value:
+case -value:
+case local:
+case -local:
+case func:
+case prefix.value:
+case -prefix.value:
+case 1 + 2:
+case 1 * 2:
+case void fun() {}:
+case assert(false):
+case switch (o) { _ => true }:
+case await 0:
+case !false:
+case ~0:
+case ++variable:
+case const Class():
+case const Class(0):
+case const GenericClass():
+case const GenericClass(a: 0):
+case const GenericClass<int>():
+case const GenericClass<int>(a: 0):
+case const GenericClass<int>.new():
+case const GenericClass<int>.new(a: 1):
+case const []:
+case const <int>[]:
+case const {}:
+case const <int, String>{}:
+case const const Class():
+case const const Class(0):
+case const const GenericClass():
+case const const GenericClass(a: 0):
+case const const GenericClass<int>():
+case const const GenericClass<int>(a: 0):
+case const const []:
+case const const <int>[]:
+case const const {}:
+case const const <int, String>{}:
+case const new Class():
+case new Class():
+case const ():
+case const const ():
+case const (1):
+case const (-1):
+case const (value):
+case const (-value):
+case const (1 + 2):
+case GenericClass<int>:
+case prefix.GenericClass<int>:
+case GenericClass<int>.new:
+case prefix.GenericClass<int>.new:
+case const (GenericClass<int>):
+case const (prefix.GenericClass<int>):
+case const (GenericClass<int>.new):
+case const (prefix.GenericClass<int>.new):
+print(0);
+}
+}
+}
+
+class GenericClass<T> {
+const GenericClass({a});
+}
+
+
+import[KeywordToken] 'const_patterns.dart'[StringToken] as[KeywordToken] prefix[StringToken];[SimpleToken]
+
+const[KeywordToken] int[StringToken] value[StringToken] =[SimpleToken] 42[StringToken];[SimpleToken]
+
+void[KeywordToken] func[StringToken]([BeginToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+
+class[KeywordToken] Class[StringToken] {[BeginToken]
+const[KeywordToken] Class[StringToken]([BeginToken][[BeginToken]a[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
+
+call[StringToken]([BeginToken])[SimpleToken] {[BeginToken]}[SimpleToken]
+
+test[StringToken]([BeginToken]o[StringToken])[SimpleToken] async[KeywordToken] {[BeginToken]
+const[KeywordToken] dynamic[KeywordToken] local[StringToken] =[SimpleToken] 0[StringToken];[SimpleToken]
+dynamic[KeywordToken] variable[StringToken] =[SimpleToken] 0[StringToken];[SimpleToken]
+switch[KeywordToken] ([BeginToken]o[StringToken])[SimpleToken] {[BeginToken]
+case[KeywordToken] true[KeywordToken]:[SimpleToken]
+case[KeywordToken] null[KeywordToken]:[SimpleToken]
+case[KeywordToken] this[KeywordToken]:[SimpleToken]
+case[KeywordToken] this[KeywordToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] super[KeywordToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] 42[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]42[StringToken]:[SimpleToken]
+case[KeywordToken] 42.5[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]42.5[StringToken]:[SimpleToken]
+case[KeywordToken] 'foo'[StringToken]:[SimpleToken]
+case[KeywordToken] 'foo'[StringToken] 'bar'[StringToken]:[SimpleToken]
+case[KeywordToken] value[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]value[StringToken]:[SimpleToken]
+case[KeywordToken] local[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]local[StringToken]:[SimpleToken]
+case[KeywordToken] func[StringToken]:[SimpleToken]
+case[KeywordToken] prefix[StringToken].[SimpleToken]value[StringToken]:[SimpleToken]
+case[KeywordToken] -[SimpleToken]prefix[StringToken].[SimpleToken]value[StringToken]:[SimpleToken]
+case[KeywordToken] 1[StringToken] +[SimpleToken] 2[StringToken]:[SimpleToken]
+case[KeywordToken] 1[StringToken] *[SimpleToken] 2[StringToken]:[SimpleToken]
+case[KeywordToken] void[KeywordToken] fun[StringToken]([BeginToken])[SimpleToken] {[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] assert[KeywordToken]([BeginToken]false[KeywordToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] switch[KeywordToken] ([BeginToken]o[StringToken])[SimpleToken] {[BeginToken] _[StringToken] =>[SimpleToken] true[KeywordToken] }[SimpleToken]:[SimpleToken]
+case[KeywordToken] await[KeywordToken] 0[StringToken]:[SimpleToken]
+case[KeywordToken] ![SimpleToken]false[KeywordToken]:[SimpleToken]
+case[KeywordToken] ~[SimpleToken]0[StringToken]:[SimpleToken]
+case[KeywordToken] ++[SimpleToken]variable[StringToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken]0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[KeywordToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[KeywordToken]([BeginToken]a[StringToken]:[SimpleToken] 1[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] [][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken]>[SimpleToken][][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] {[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken],[SimpleToken] String[StringToken]>[SimpleToken]{[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] Class[StringToken]([BeginToken]0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]([BeginToken]a[StringToken]:[SimpleToken] 0[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] [][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken]>[SimpleToken][][SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] {[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] <[BeginToken]int[StringToken],[SimpleToken] String[StringToken]>[SimpleToken]{[BeginToken]}[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] new[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] new[KeywordToken] Class[StringToken]([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] const[KeywordToken] ([BeginToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]1[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]-[SimpleToken]1[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]value[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]-[SimpleToken]value[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]1[StringToken] +[SimpleToken] 2[StringToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]:[SimpleToken]
+case[KeywordToken] prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken]:[SimpleToken]
+case[KeywordToken] GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[KeywordToken]:[SimpleToken]
+case[KeywordToken] prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[KeywordToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[KeywordToken])[SimpleToken]:[SimpleToken]
+case[KeywordToken] const[KeywordToken] ([BeginToken]prefix[StringToken].[SimpleToken]GenericClass[StringToken]<[BeginToken]int[StringToken]>[SimpleToken].[SimpleToken]new[KeywordToken])[SimpleToken]:[SimpleToken]
+print[StringToken]([BeginToken]0[StringToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+}[SimpleToken]
+
+class[KeywordToken] GenericClass[StringToken]<[BeginToken]T[StringToken]>[SimpleToken] {[BeginToken]
+const[KeywordToken] GenericClass[StringToken]([BeginToken]{[BeginToken]a[StringToken]}[SimpleToken])[SimpleToken];[SimpleToken]
+}[SimpleToken]
+[SimpleToken]

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart.intertwined.expect
index ecac091..48b7a4b 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_builtin.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(as)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -70,7 +70,7 @@
                                     parseArgumentsOpt(abstract)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(abstract, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               inPlainSync()
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
@@ -83,7 +83,7 @@
                                     listener: handleNoArguments(.)
                                   listener: handleSend(as, .)
                             listener: handleEndingBinaryExpression(.)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               inPlainSync()
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
@@ -111,9 +111,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -134,9 +134,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             inPlainSync()
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
@@ -148,7 +148,7 @@
                                 parseArgumentsOpt(abstract)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(abstract, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
@@ -161,7 +161,7 @@
                                 listener: handleNoArguments(.)
                               listener: handleSend(as, .)
                         listener: handleEndingBinaryExpression(.)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCase.dart.intertwined.expect
index 812dc21..3a8f847 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -95,7 +95,7 @@
                                 listener: handleNoArguments(.)
                               listener: handleSend(b, .)
                         listener: handleEndingBinaryExpression(.)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCast.dart.intertwined.expect
index 52fabe4..87030b4 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -95,7 +95,7 @@
                                 listener: handleNoArguments(.)
                               listener: handleSend(b, .)
                         listener: handleEndingBinaryExpression(.)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideIfCase.dart.intertwined.expect
index ab26cf5..629659f 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseSendOrFunctionLiteral(case, expression)
                                 parseSend(case, expression)
                                   isNextIdentifier(case)
@@ -76,7 +76,7 @@
                                   parseArgumentsOpt(a)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(a, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)
@@ -87,7 +87,7 @@
                                   listener: handleNoArguments(.)
                                 listener: handleSend(b, .)
                           listener: handleEndingBinaryExpression(.)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullAssert.dart.intertwined.expect
index ceedfc1..bd45d3b 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -95,7 +95,7 @@
                                 listener: handleNoArguments(.)
                               listener: handleSend(b, .)
                         listener: handleEndingBinaryExpression(.)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullCheck.dart.intertwined.expect
index 094b3ca..7ec5400 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -95,7 +95,7 @@
                                 listener: handleNoArguments(.)
                               listener: handleSend(b, .)
                         listener: handleEndingBinaryExpression(.)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_pseudoKeyword.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_pseudoKeyword.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_pseudoKeyword.dart.intertwined.expect
index e8bbe41..e21fa3d 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_pseudoKeyword.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_doublyPrefixed_pseudoKeyword.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(hide)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -70,7 +70,7 @@
                                     parseArgumentsOpt(show)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(show, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               inPlainSync()
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
@@ -83,7 +83,7 @@
                                     listener: handleNoArguments(.)
                                   listener: handleSend(hide, .)
                             listener: handleEndingBinaryExpression(.)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               inPlainSync()
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
@@ -111,9 +111,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -134,9 +134,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             inPlainSync()
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
@@ -148,7 +148,7 @@
                                 parseArgumentsOpt(show)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(show, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
@@ -161,7 +161,7 @@
                                 listener: handleNoArguments(.)
                               listener: handleSend(hide, .)
                         listener: handleEndingBinaryExpression(.)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)

pkg/front_end/parser_testcases/patterns/constant_identifier_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_case.dart.intertwined.expect
index b58b221..38912e3 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_case.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/constant_identifier_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_cast.dart.intertwined.expect
index eb06238..06b1145 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_cast.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/constant_identifier_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_if_case.dart.intertwined.expect
index 42aaea1..b45d50f 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_if_case.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -93,9 +93,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseSendOrFunctionLiteral(case, expression)
                                 parseSend(case, expression)
                                   isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_assert.dart.intertwined.expect
index ad54182..35381ad 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_assert.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_check.dart.intertwined.expect
index 231a465..cb4eee9 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_inside_null_check.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixedWithUnderscore_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixedWithUnderscore_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixedWithUnderscore_insideCase.dart.intertwined.expect
index 2dc5a86..bb63121 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixedWithUnderscore_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixedWithUnderscore_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -69,9 +69,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -81,7 +81,7 @@
                                 parseArgumentsOpt(_)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(_, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_builtin.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_builtin.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_builtin.dart.intertwined.expect
index 3e35d7e..57089725 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_builtin.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_builtin.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(as)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -70,7 +70,7 @@
                                     parseArgumentsOpt(abstract)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(abstract, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               inPlainSync()
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
@@ -98,9 +98,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -121,9 +121,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             inPlainSync()
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
@@ -135,7 +135,7 @@
                                 parseArgumentsOpt(abstract)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(abstract, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCase.dart.intertwined.expect
index 2783466..6127ca5 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCast.dart.intertwined.expect
index a6d3ead..7474ff0 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideIfCase.dart.intertwined.expect
index 6c2fd2e..82da548 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseSendOrFunctionLiteral(case, expression)
                                 parseSend(case, expression)
                                   isNextIdentifier(case)
@@ -76,7 +76,7 @@
                                   parseArgumentsOpt(a)
                                     listener: handleNoArguments(.)
                                   listener: handleSend(a, .)
-                          parsePrimary(., expressionContinuation)
+                          parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
                                 isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullAssert.dart.intertwined.expect
index 7baa590..36bb711 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullCheck.dart.intertwined.expect
index 7b22f54..97a3150 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -84,7 +84,7 @@
                                 parseArgumentsOpt(a)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(a, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)

pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_pseudoKeyword.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_pseudoKeyword.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_pseudoKeyword.dart.intertwined.expect
index c416d42..05da157 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_pseudoKeyword.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_prefixed_pseudoKeyword.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(hide)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -70,7 +70,7 @@
                                     parseArgumentsOpt(show)
                                       listener: handleNoArguments(.)
                                     listener: handleSend(show, .)
-                            parsePrimary(., expressionContinuation)
+                            parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                               inPlainSync()
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
@@ -98,9 +98,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -121,9 +121,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             inPlainSync()
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
@@ -135,7 +135,7 @@
                                 parseArgumentsOpt(show)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(show, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)

pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_beforeWhen.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_beforeWhen.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_beforeWhen.dart.intertwined.expect
index 1770b07c..99fca8b 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_beforeWhen.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_beforeWhen.dart.intertwined.expect
@@ -55,9 +55,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -75,9 +75,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -98,9 +98,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)
@@ -115,9 +115,9 @@
                   parseExpression(when)
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseLiteralBool(when)
                             listener: handleLiteralBool(true)
                   listener: endSwitchCaseWhenClause(true)

pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_builtin.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_builtin.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_builtin.dart.intertwined.expect
index 0adc43e..db58d29 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_builtin.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_builtin.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(abstract)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -85,9 +85,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -108,9 +108,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             inPlainSync()
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)

pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_insideSwitchExpression.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_insideSwitchExpression.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_insideSwitchExpression.dart.intertwined.expect
index 7b967ca..9b2c771 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_insideSwitchExpression.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_insideSwitchExpression.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -71,9 +71,9 @@
                       parsePattern({, PatternContext.matching, precedence: 1)
                         parsePrimaryPattern({, PatternContext.matching)
                           listener: beginConstantPattern(null)
-                          parsePrecedenceExpression({, 17, false)
-                            parseUnaryExpression({, false)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 17, false, ConstantPatternContext.implicit)
+                            parseUnaryExpression({, false, ConstantPatternContext.implicit)
+                              parsePrimary({, expression, ConstantPatternContext.implicit)
                                 parseSendOrFunctionLiteral({, expression)
                                   parseSend({, expression)
                                     isNextIdentifier({)
@@ -89,9 +89,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_pseudoKeyword.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_pseudoKeyword.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_pseudoKeyword.dart.intertwined.expect
index d2389ae..67b925a 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_pseudoKeyword.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_identifier_unprefixed_pseudoKeyword.dart.intertwined.expect
@@ -56,9 +56,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(show)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 inPlainSync()
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
@@ -85,9 +85,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -108,9 +108,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             inPlainSync()
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)

pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCase.dart.intertwined.expect
index 4f5f2a9..175c740 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)

pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCast.dart.intertwined.expect
index 8c084cc..3dd3bef 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)

pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideIfCase.dart.intertwined.expect
index 1086561..50c0413 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               parseLiteralListSetMapOrFunction(const, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(int, typeReference)

pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullAssert.dart.intertwined.expect
index 96d8e9f..d0a8c49 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)

pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullCheck.dart.intertwined.expect
index 68feb58..343184f 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_empty_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)

pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCase.dart.intertwined.expect
index 071795bf..a494e73 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression([)
                                   looksLikeOuterPatternEquals([)
                                     skipOuterPattern([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCast.dart.intertwined.expect
index cd5056b..d712367 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression([)
                                   looksLikeOuterPatternEquals([)
                                     skipOuterPattern([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideIfCase.dart.intertwined.expect
index 59d3ccf..bc91278 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               parseLiteralListSetMapOrFunction(const, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(int, typeReference)
@@ -77,9 +77,9 @@
                                   parseExpression([)
                                     looksLikeOuterPatternEquals([)
                                       skipOuterPattern([)
-                                    parsePrecedenceExpression([, 1, true)
-                                      parseUnaryExpression([, true)
-                                        parsePrimary([, expression)
+                                    parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression([, true, ConstantPatternContext.none)
+                                        parsePrimary([, expression, ConstantPatternContext.none)
                                           parseLiteralInt([)
                                             listener: handleLiteralInt(1)
                                   listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullAssert.dart.intertwined.expect
index 74a0459..a26e1ab 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression([)
                                   looksLikeOuterPatternEquals([)
                                     skipOuterPattern([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullCheck.dart.intertwined.expect
index 2f8dd27..054a1fd 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_typed_nonEmpty_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression([)
                                   looksLikeOuterPatternEquals([)
                                     skipOuterPattern([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCase.dart.intertwined.expect
index e3e336e..b0076e6 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([])
                             parseLiteralListSuffix(const, null)
                               rewriteSquareBrackets(const)

pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCast.dart.intertwined.expect
index c9f42db..0c54770 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([])
                             parseLiteralListSuffix(const, null)
                               rewriteSquareBrackets(const)

pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideIfCase.dart.intertwined.expect
index 4cbd5d5..088b906 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               listener: handleNoTypeArguments([])
                               parseLiteralListSuffix(const, null)
                                 rewriteSquareBrackets(const)

pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullAssert.dart.intertwined.expect
index 4d0b365..cb98ce7 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([])
                             parseLiteralListSuffix(const, null)
                               rewriteSquareBrackets(const)

pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullCheck.dart.intertwined.expect
index 0caeaca..32276fa 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_empty_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([])
                             parseLiteralListSuffix(const, null)
                               rewriteSquareBrackets(const)

pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCase.dart.intertwined.expect
index d2ca4ba..7907a18 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(const, null)
                               parseExpression([)
                                 looksLikeOuterPatternEquals([)
                                   skipOuterPattern([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralInt([)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCast.dart.intertwined.expect
index 32c05ef..3c5409c 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(const, null)
                               parseExpression([)
                                 looksLikeOuterPatternEquals([)
                                   skipOuterPattern([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralInt([)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideIfCase.dart.intertwined.expect
index 704ca9b2..49047ae 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,17 +64,17 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(const, null)
                                 parseExpression([)
                                   looksLikeOuterPatternEquals([)
                                     skipOuterPattern([)
-                                  parsePrecedenceExpression([, 1, true)
-                                    parseUnaryExpression([, true)
-                                      parsePrimary([, expression)
+                                  parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression([, true, ConstantPatternContext.none)
+                                      parsePrimary([, expression, ConstantPatternContext.none)
                                         parseLiteralInt([)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullAssert.dart.intertwined.expect
index 0ec549c..578c2d2 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(const, null)
                               parseExpression([)
                                 looksLikeOuterPatternEquals([)
                                   skipOuterPattern([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralInt([)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullCheck.dart.intertwined.expect
index 87511ca..5a8ea48 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_list_untyped_nonEmpty_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(const, null)
                               parseExpression([)
                                 looksLikeOuterPatternEquals([)
                                   skipOuterPattern([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
                                       parseLiteralInt([)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralList(1, [, null, ])

pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCase.dart.intertwined.expect
index 89eea89..4857dc4 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -88,17 +88,17 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 parseExpression(:)
                                   looksLikeOuterPatternEquals(:)
                                     skipOuterPattern(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(2)
                                 listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCast.dart.intertwined.expect
index 30e6164..9217bb2 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -88,17 +88,17 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 parseExpression(:)
                                   looksLikeOuterPatternEquals(:)
                                     skipOuterPattern(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(2)
                                 listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_typed_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideIfCase.dart.intertwined.expect
index a3ca76e..30813e5 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               parseLiteralListSetMapOrFunction(const, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(int, typeReference)
@@ -80,17 +80,17 @@
                                   parseExpression({)
                                     looksLikeOuterPatternEquals({)
                                       skipOuterPattern({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralInt({)
                                             listener: handleLiteralInt(1)
                                   parseExpression(:)
                                     looksLikeOuterPatternEquals(:)
                                       skipOuterPattern(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(2)
                                   listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullAssert.dart.intertwined.expect
index 68ae803..589913a 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -88,17 +88,17 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 parseExpression(:)
                                   looksLikeOuterPatternEquals(:)
                                     skipOuterPattern(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(2)
                                 listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullCheck.dart.intertwined.expect
index 08d82be..720ccac 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_typed_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -88,17 +88,17 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 parseExpression(:)
                                   looksLikeOuterPatternEquals(:)
                                     skipOuterPattern(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(2)
                                 listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCase.dart.intertwined.expect
index 36e2e7e..883e5fb 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,25 +72,25 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralInt(:)
                                         listener: handleLiteralInt(2)
                               listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCast.dart.intertwined.expect
index d0061ee..4a58776 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,25 +72,25 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralInt(:)
                                         listener: handleLiteralInt(2)
                               listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideIfCase.dart.intertwined.expect
index 0418d61..88f5d6f 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,25 +64,25 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(const, null)
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 parseExpression(:)
                                   looksLikeOuterPatternEquals(:)
                                     skipOuterPattern(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(2)
                                 listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullAssert.dart.intertwined.expect
index db1a1d0..a27ac6d 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,25 +72,25 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralInt(:)
                                         listener: handleLiteralInt(2)
                               listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullCheck.dart.intertwined.expect
index 01a40a8..d6c060d 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_map_untyped_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,25 +72,25 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
                                       parseLiteralInt(:)
                                         listener: handleLiteralInt(2)
                               listener: handleLiteralMapEntry(:, })

pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCase.dart.intertwined.expect
index 287a2f0..0260952 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseSendOrFunctionLiteral(const, expression)
                               looksLikeFunctionBody(:)
                               parseSend(const, expression)
@@ -89,9 +89,9 @@
                                       parseExpression(()
                                         looksLikeOuterPatternEquals(()
                                           skipOuterPattern(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseLiteralInt(()
                                                 listener: handleLiteralInt(1)
                                       listener: endArguments(1, (, ))

pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCast.dart.intertwined.expect
index c35a81d..67c6b57 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseSendOrFunctionLiteral(const, expression)
                               looksLikeFunctionBody(as)
                               parseSend(const, expression)
@@ -89,9 +89,9 @@
                                       parseExpression(()
                                         looksLikeOuterPatternEquals(()
                                           skipOuterPattern(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseLiteralInt(()
                                                 listener: handleLiteralInt(1)
                                       listener: endArguments(1, (, ))

pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideIfCase.dart.intertwined.expect
index 2e54b24..517ea92 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               parseSendOrFunctionLiteral(const, expression)
                                 looksLikeFunctionBody())
                                 parseSend(const, expression)
@@ -81,9 +81,9 @@
                                         parseExpression(()
                                           looksLikeOuterPatternEquals(()
                                             skipOuterPattern(()
-                                          parsePrecedenceExpression((, 1, true)
-                                            parseUnaryExpression((, true)
-                                              parsePrimary((, expression)
+                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                 parseLiteralInt(()
                                                   listener: handleLiteralInt(1)
                                         listener: endArguments(1, (, ))

pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullAssert.dart.intertwined.expect
index caf3483..e17a61c 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseSendOrFunctionLiteral(const, expression)
                               looksLikeFunctionBody(!)
                               parseSend(const, expression)
@@ -89,9 +89,9 @@
                                       parseExpression(()
                                         looksLikeOuterPatternEquals(()
                                           skipOuterPattern(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseLiteralInt(()
                                                 listener: handleLiteralInt(1)
                                       listener: endArguments(1, (, ))

pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullCheck.dart.intertwined.expect
index 5d08812..19a6a5d 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_objectExpression_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseSendOrFunctionLiteral(const, expression)
                               looksLikeFunctionBody(?)
                               parseSend(const, expression)
@@ -89,9 +89,9 @@
                                       parseExpression(()
                                         looksLikeOuterPatternEquals(()
                                           skipOuterPattern(()
-                                        parsePrecedenceExpression((, 1, true)
-                                          parseUnaryExpression((, true)
-                                            parsePrimary((, expression)
+                                        parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression((, true, ConstantPatternContext.none)
+                                            parsePrimary((, expression, ConstantPatternContext.none)
                                               parseLiteralInt(()
                                                 listener: handleLiteralInt(1)
                                       listener: endArguments(1, (, ))

pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCase.dart.intertwined.expect
index 383ed19..1761a64 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,18 +72,18 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const)
-                              parseParenthesizedExpressionOrRecordLiteral(const, null)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                              parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(1)
                                 ensureCloseParen(1, ()

pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCast.dart.intertwined.expect
index 3f53114..f664276 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,18 +72,18 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const)
-                              parseParenthesizedExpressionOrRecordLiteral(const, null)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                              parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(1)
                                 ensureCloseParen(1, ()

pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideIfCase.dart.intertwined.expect
index d0c223a..caf84c9 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,18 +64,18 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const)
-                                parseParenthesizedExpressionOrRecordLiteral(const, null)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
                                     looksLikeOuterPatternEquals(()
                                       skipOuterPattern(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(1)
                                   ensureCloseParen(1, ()

pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullAssert.dart.intertwined.expect
index bea0ab0..ee22fcd 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,18 +72,18 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const)
-                              parseParenthesizedExpressionOrRecordLiteral(const, null)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                              parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(1)
                                 ensureCloseParen(1, ()

pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullCheck.dart.intertwined.expect
index c2d2d0a..1a5d938 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_parenthesized_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,18 +72,18 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const)
-                              parseParenthesizedExpressionOrRecordLiteral(const, null)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                              parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(1)
                                 ensureCloseParen(1, ()

pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCase.dart.intertwined.expect
index e589086..05387cd 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCast.dart.intertwined.expect
index c918eaa..b1a7dc6 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_typed_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideIfCase.dart.intertwined.expect
index 38e6545..29884c0 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               parseLiteralListSetMapOrFunction(const, null)
                                 listener: beginTypeArguments(<)
                                 listener: handleIdentifier(int, typeReference)
@@ -77,9 +77,9 @@
                                   parseExpression({)
                                     looksLikeOuterPatternEquals({)
                                       skipOuterPattern({)
-                                    parsePrecedenceExpression({, 1, true)
-                                      parseUnaryExpression({, true)
-                                        parsePrimary({, expression)
+                                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                                        parsePrimary({, expression, ConstantPatternContext.none)
                                           parseLiteralInt({)
                                             listener: handleLiteralInt(1)
                                   listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullAssert.dart.intertwined.expect
index b6072a9..6e3bedc 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullCheck.dart.intertwined.expect
index 12f8bc5..e32a8cf 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_typed_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             parseLiteralListSetMapOrFunction(const, null)
                               listener: beginTypeArguments(<)
                               listener: handleIdentifier(int, typeReference)
@@ -85,9 +85,9 @@
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCase.dart.intertwined.expect
index b892b52..a59f115 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCast.dart.intertwined.expect
index b6cb6b6..7469ad1 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideCast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideIfCase.dart.intertwined.expect
index a82ab76..3617b35 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideIfCase.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,17 +64,17 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(const)
-                        parsePrecedenceExpression(const, 17, false)
-                          parseUnaryExpression(const, false)
-                            parsePrimary(const, expression)
+                        parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                          parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                            parsePrimary(const, expression, ConstantPatternContext.explicit)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(const, null)
                                 parseExpression({)
                                   looksLikeOuterPatternEquals({)
                                     skipOuterPattern({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseLiteralInt({)
                                           listener: handleLiteralInt(1)
                                 listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullAssert.dart.intertwined.expect
index 2de699f..893b19d 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullAssert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullCheck.dart.intertwined.expect
index 1a01d2c..a655b5c 100644
--- a/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/constant_set_untyped_insideNullCheck.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,17 +72,17 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(const)
-                      parsePrecedenceExpression(const, 17, false)
-                        parseUnaryExpression(const, false)
-                          parsePrimary(const, expression)
+                      parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                        parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                          parsePrimary(const, expression, ConstantPatternContext.explicit)
                             listener: handleNoTypeArguments({)
                             parseLiteralSetOrMapSuffix(const, null)
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralInt({)
                                         listener: handleLiteralInt(1)
                               listener: handleLiteralSetOrMap(1, {, null, }, true)

pkg/front_end/parser_testcases/patterns/double_literal_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/double_literal_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/double_literal_inside_case.dart.intertwined.expect
index 2121246..ee6989c 100644
--- a/pkg/front_end/parser_testcases/patterns/double_literal_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/double_literal_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralDouble(case)
                               listener: handleLiteralDouble(1.0)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/double_literal_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/double_literal_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/double_literal_inside_cast.dart.intertwined.expect
index e69f46a..d28716f 100644
--- a/pkg/front_end/parser_testcases/patterns/double_literal_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/double_literal_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralDouble(case)
                               listener: handleLiteralDouble(1.0)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/double_literal_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/double_literal_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/double_literal_inside_if_case.dart.intertwined.expect
index 90f5c5d..137f521 100644
--- a/pkg/front_end/parser_testcases/patterns/double_literal_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/double_literal_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralDouble(case)
                                 listener: handleLiteralDouble(1.0)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/double_literal_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_assert.dart.intertwined.expect
index 7b5f320..8c459f36 100644
--- a/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralDouble(case)
                               listener: handleLiteralDouble(1.0)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/double_literal_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_check.dart.intertwined.expect
index 09b77b8..8a39152 100644
--- a/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/double_literal_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralDouble(case)
                               listener: handleLiteralDouble(1.0)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/error_recovery_after_question_suffix_in_expression.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/error_recovery_after_question_suffix_in_expression.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/error_recovery_after_question_suffix_in_expression.dart.intertwined.expect
index 808665b..595db39 100644
--- a/pkg/front_end/parser_testcases/patterns/error_recovery_after_question_suffix_in_expression.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/error_recovery_after_question_suffix_in_expression.dart.intertwined.expect
@@ -44,17 +44,17 @@
                             parseExpression({)
                               looksLikeOuterPatternEquals({)
                                 skipOuterPattern({)
-                              parsePrecedenceExpression({, 1, true)
-                                parseUnaryExpression({, true)
-                                  parsePrimary({, expression)
+                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                  parsePrimary({, expression, ConstantPatternContext.none)
                                     parseLiteralBool({)
                                       listener: handleLiteralBool(true)
                                 parseConditionalExpressionRest(true)
                                   listener: beginConditionalExpression(?)
                                   parseExpressionWithoutCascade(?)
-                                    parsePrecedenceExpression(?, 1, false)
-                                      parseUnaryExpression(?, false)
-                                        parsePrimary(?, expression)
+                                    parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                        parsePrimary(?, expression, ConstantPatternContext.none)
                                           parseSend(?, expression)
                                             isNextIdentifier(?)
                                             ensureIdentifier(?, expression)
@@ -69,9 +69,9 @@
                                   ensureColon()
                                   listener: handleConditionalExpressionColon()
                                   parseExpressionWithoutCascade(:)
-                                    parsePrecedenceExpression(:, 1, false)
-                                      parseUnaryExpression(:, false)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(2)
                                   listener: endConditionalExpression(?, :)

pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_cast.dart.intertwined.expect
index e0ae493..6253c42 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_cast.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -122,9 +122,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_assert.dart.intertwined.expect
index b5a31ea..49c7964 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_assert.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -122,9 +122,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_check.dart.intertwined.expect
index a9ed211..3c35404 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_pattern_inside_null_check.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -122,9 +122,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args.dart.intertwined.expect
index a94bfdd..58b0d1f 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args.dart.intertwined.expect
@@ -84,9 +84,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect
index 99d019c..33e3dc5 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect
@@ -101,9 +101,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -134,9 +134,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect
index ab6ae5c..a1aa77f 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect
index d6dee20..e19ef35 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_prefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect
index ab6df68..ef268b5 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withTypeArgs_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect
index a405a11..6294a32 100644
--- a/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/extractor_unprefixedNamedUnderscore_withoutTypeArgs_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/final_variable_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/final_variable_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/final_variable_inside_case.dart.intertwined.expect
index 0edeb70..cb180e5 100644
--- a/pkg/front_end/parser_testcases/patterns/final_variable_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/final_variable_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/final_variable_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/final_variable_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/final_variable_inside_cast.dart.intertwined.expect
index c3cc4c3..f077161 100644
--- a/pkg/front_end/parser_testcases/patterns/final_variable_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/final_variable_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/final_variable_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/final_variable_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/final_variable_inside_if_case.dart.intertwined.expect
index fbe35fd..0e46be0 100644
--- a/pkg/front_end/parser_testcases/patterns/final_variable_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/final_variable_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/final_variable_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_assert.dart.intertwined.expect
index 24adc1d..509d415 100644
--- a/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/final_variable_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_check.dart.intertwined.expect
index 214dc34..55ce5d1a 100644
--- a/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/final_variable_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_afterSwitchExpression.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_afterSwitchExpression.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_afterSwitchExpression.dart.intertwined.expect
index b1b0144..c540c92 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_afterSwitchExpression.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_afterSwitchExpression.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -70,10 +70,10 @@
                       listener: endSwitchExpressionBlock(0, {, })
                       listener: endSwitchExpression(switch, })
                 listener: beginBinaryExpression(+)
-                parsePrecedenceExpression(+, 14, true)
-                  parseUnaryExpression(+, true)
-                    parsePrimary(+, expression)
-                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+)
+                parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                  parseUnaryExpression(+, true, ConstantPatternContext.none)
+                    parsePrimary(+, expression, ConstantPatternContext.none)
+                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+, ConstantPatternContext.none)
                         listener: handleNoTypeVariables(()
                         parseFunctionExpression(+)
                           listener: beginFunctionExpression(()
@@ -90,9 +90,9 @@
                                 parseExpression(=>)
                                   looksLikeOuterPatternEquals(=>)
                                     skipOuterPattern(=>)
-                                  parsePrecedenceExpression(=>, 1, true)
-                                    parseUnaryExpression(=>, true)
-                                      parsePrimary(=>, expression)
+                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                      parsePrimary(=>, expression, ConstantPatternContext.none)
                                         parseLiteralInt(=>)
                                           listener: handleLiteralInt(0)
                                 listener: handleExpressionFunctionBody(=>, null)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_element.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_element.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_element.dart.intertwined.expect
index 478313a..256fc52 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_element.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_element.dart.intertwined.expect
@@ -49,9 +49,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     listener: handleNoTypeArguments([)
                     parseLiteralListSuffix(=>, null)
                       listener: beginIfControlFlow(if)
@@ -61,9 +61,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -83,9 +83,9 @@
                             looksLikeOuterPatternEquals(when)
                               skipOuterPattern(when)
                                 skipObjectPatternRest(y)
-                            parsePrecedenceExpression(when, 1, true)
-                              parseUnaryExpression(when, true)
-                                parsePrimary(when, expression)
+                            parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(when, true, ConstantPatternContext.none)
+                                parsePrimary(when, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(when, expression)
                                     parseSend(when, expression)
                                       isNextIdentifier(when)
@@ -96,10 +96,10 @@
                                         listener: handleNoArguments(+)
                                       listener: handleSend(y, +)
                               listener: beginBinaryExpression(+)
-                              parsePrecedenceExpression(+, 14, true)
-                                parseUnaryExpression(+, true)
-                                  parsePrimary(+, expression)
-                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+)
+                              parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                                parseUnaryExpression(+, true, ConstantPatternContext.none)
+                                  parsePrimary(+, expression, ConstantPatternContext.none)
+                                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+, ConstantPatternContext.none)
                                       listener: handleNoTypeVariables(()
                                       parseFunctionExpression(+)
                                         listener: beginFunctionExpression(()
@@ -116,9 +116,9 @@
                                               parseExpression(=>)
                                                 looksLikeOuterPatternEquals(=>)
                                                   skipOuterPattern(=>)
-                                                parsePrecedenceExpression(=>, 1, true)
-                                                  parseUnaryExpression(=>, true)
-                                                    parsePrimary(=>, expression)
+                                                parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                    parsePrimary(=>, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(=>)
                                                         listener: handleLiteralInt(0)
                                               listener: handleExpressionFunctionBody(=>, null)
@@ -132,9 +132,9 @@
                       parseExpression())
                         looksLikeOuterPatternEquals())
                           skipOuterPattern())
-                        parsePrecedenceExpression(), 1, true)
-                          parseUnaryExpression(), true)
-                            parsePrimary(), expression)
+                        parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(), true, ConstantPatternContext.none)
+                            parsePrimary(), expression, ConstantPatternContext.none)
                               parseLiteralInt())
                                 listener: handleLiteralInt(0)
                       listener: endIfControlFlow(0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_statement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_statement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_statement.dart.intertwined.expect
index 8cc9afd..39f3842 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_statement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideIfCaseWhenClause_statement.dart.intertwined.expect
@@ -57,9 +57,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -79,9 +79,9 @@
                       looksLikeOuterPatternEquals(when)
                         skipOuterPattern(when)
                           skipObjectPatternRest(y)
-                      parsePrecedenceExpression(when, 1, true)
-                        parseUnaryExpression(when, true)
-                          parsePrimary(when, expression)
+                      parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(when, true, ConstantPatternContext.none)
+                          parsePrimary(when, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(when, expression)
                               parseSend(when, expression)
                                 isNextIdentifier(when)
@@ -92,10 +92,10 @@
                                   listener: handleNoArguments(+)
                                 listener: handleSend(y, +)
                         listener: beginBinaryExpression(+)
-                        parsePrecedenceExpression(+, 14, true)
-                          parseUnaryExpression(+, true)
-                            parsePrimary(+, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+)
+                        parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                          parseUnaryExpression(+, true, ConstantPatternContext.none)
+                            parsePrimary(+, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+, ConstantPatternContext.none)
                                 listener: handleNoTypeVariables(()
                                 parseFunctionExpression(+)
                                   listener: beginFunctionExpression(()
@@ -112,9 +112,9 @@
                                         parseExpression(=>)
                                           looksLikeOuterPatternEquals(=>)
                                             skipOuterPattern(=>)
-                                          parsePrecedenceExpression(=>, 1, true)
-                                            parseUnaryExpression(=>, true)
-                                              parsePrimary(=>, expression)
+                                          parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                            parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                              parsePrimary(=>, expression, ConstantPatternContext.none)
                                                 parseLiteralInt(=>)
                                                   listener: handleLiteralInt(0)
                                         listener: handleExpressionFunctionBody(=>, null)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideListPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideListPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideListPattern.dart.intertwined.expect
index 47c5905..d1c8b6e 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideListPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideListPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -74,10 +74,10 @@
                           parseListPatternSuffix({, PatternContext.matching)
                             parsePattern([, PatternContext.matching, precedence: 1)
                               parsePrimaryPattern([, PatternContext.matching)
-                                parsePrecedenceExpression(==, 12, false)
-                                  parseUnaryExpression(==, false)
-                                    parsePrimary(==, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==)
+                                parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==, ConstantPatternContext.none)
                                         listener: handleNoTypeVariables(()
                                         parseFunctionExpression(==)
                                           listener: beginFunctionExpression(()
@@ -94,9 +94,9 @@
                                                 parseExpression(=>)
                                                   looksLikeOuterPatternEquals(=>)
                                                     skipOuterPattern(=>)
-                                                  parsePrecedenceExpression(=>, 1, true)
-                                                    parseUnaryExpression(=>, true)
-                                                      parsePrimary(=>, expression)
+                                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                      parsePrimary(=>, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(=>)
                                                           listener: handleLiteralInt(0)
                                                 listener: handleExpressionFunctionBody(=>, null)
@@ -109,9 +109,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideMapPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideMapPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideMapPattern.dart.intertwined.expect
index 564973e..98be52d 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideMapPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideMapPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -75,19 +75,19 @@
                             parseExpression({)
                               looksLikeOuterPatternEquals({)
                                 skipOuterPattern({)
-                              parsePrecedenceExpression({, 1, true)
-                                parseUnaryExpression({, true)
-                                  parsePrimary({, expression)
+                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                  parsePrimary({, expression, ConstantPatternContext.none)
                                     parseLiteralString({)
                                       parseSingleLiteralString({)
                                         listener: beginLiteralString('x')
                                         listener: endLiteralString(0, :)
                             parsePattern(:, PatternContext.matching, precedence: 1)
                               parsePrimaryPattern(:, PatternContext.matching)
-                                parsePrecedenceExpression(==, 12, false)
-                                  parseUnaryExpression(==, false)
-                                    parsePrimary(==, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==)
+                                parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==, ConstantPatternContext.none)
                                         listener: handleNoTypeVariables(()
                                         parseFunctionExpression(==)
                                           listener: beginFunctionExpression(()
@@ -104,9 +104,9 @@
                                                 parseExpression(=>)
                                                   looksLikeOuterPatternEquals(=>)
                                                     skipOuterPattern(=>)
-                                                  parsePrecedenceExpression(=>, 1, true)
-                                                    parseUnaryExpression(=>, true)
-                                                      parsePrimary(=>, expression)
+                                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                      parsePrimary(=>, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(=>)
                                                           listener: handleLiteralInt(0)
                                                 listener: handleExpressionFunctionBody(=>, null)
@@ -120,9 +120,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideObjectPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideObjectPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideObjectPattern.dart.intertwined.expect
index 9eb7839..3c59be41 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideObjectPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideObjectPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -76,10 +76,10 @@
                               listener: handleIdentifier(bar, namedArgumentReference)
                             parsePattern(:, PatternContext.matching, precedence: 1)
                               parsePrimaryPattern(:, PatternContext.matching)
-                                parsePrecedenceExpression(==, 12, false)
-                                  parseUnaryExpression(==, false)
-                                    parsePrimary(==, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==)
+                                parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==, ConstantPatternContext.none)
                                         listener: handleNoTypeVariables(()
                                         parseFunctionExpression(==)
                                           listener: beginFunctionExpression(()
@@ -96,9 +96,9 @@
                                                 parseExpression(=>)
                                                   looksLikeOuterPatternEquals(=>)
                                                     skipOuterPattern(=>)
-                                                  parsePrecedenceExpression(=>, 1, true)
-                                                    parseUnaryExpression(=>, true)
-                                                      parsePrimary(=>, expression)
+                                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                      parsePrimary(=>, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(=>)
                                                           listener: handleLiteralInt(0)
                                                 listener: handleExpressionFunctionBody(=>, null)
@@ -113,9 +113,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedConstPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedConstPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedConstPattern.dart.intertwined.expect
index c6e65bb..0931e22 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedConstPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedConstPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -71,19 +71,19 @@
                       parsePattern({, PatternContext.matching, precedence: 1)
                         parsePrimaryPattern({, PatternContext.matching)
                           listener: beginConstantPattern(const)
-                          parsePrecedenceExpression(const, 17, false)
-                            parseUnaryExpression(const, false)
-                              parsePrimary(const, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const)
-                                  parseParenthesizedExpressionOrRecordLiteral(const, null)
+                          parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                            parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                              parsePrimary(const, expression, ConstantPatternContext.explicit)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(const, ConstantPatternContext.explicit)
+                                  parseParenthesizedExpressionOrRecordLiteral(const, null, ConstantPatternContext.explicit)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
                                       looksLikeOuterPatternEquals(()
                                         skipOuterPattern(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                               listener: handleNoTypeVariables(()
                                               parseFunctionExpression(()
                                                 listener: beginFunctionExpression(()
@@ -100,9 +100,9 @@
                                                       parseExpression(=>)
                                                         looksLikeOuterPatternEquals(=>)
                                                           skipOuterPattern(=>)
-                                                        parsePrecedenceExpression(=>, 1, true)
-                                                          parseUnaryExpression(=>, true)
-                                                            parsePrimary(=>, expression)
+                                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                                               parseLiteralInt(=>)
                                                                 listener: handleLiteralInt(0)
                                                       listener: handleExpressionFunctionBody(=>, null)
@@ -116,9 +116,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedPattern.dart.intertwined.expect
index 9048b3d..f9da04b 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideParenthesizedPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -73,10 +73,10 @@
                           parseParenthesizedPatternOrRecordPattern({, PatternContext.matching)
                             parsePattern((, PatternContext.matching, precedence: 1)
                               parsePrimaryPattern((, PatternContext.matching)
-                                parsePrecedenceExpression(==, 12, false)
-                                  parseUnaryExpression(==, false)
-                                    parsePrimary(==, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==)
+                                parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                                  parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                    parsePrimary(==, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(==, ConstantPatternContext.none)
                                         listener: handleNoTypeVariables(()
                                         parseFunctionExpression(==)
                                           listener: beginFunctionExpression(()
@@ -93,9 +93,9 @@
                                                 parseExpression(=>)
                                                   looksLikeOuterPatternEquals(=>)
                                                     skipOuterPattern(=>)
-                                                  parsePrecedenceExpression(=>, 1, true)
-                                                    parseUnaryExpression(=>, true)
-                                                      parsePrimary(=>, expression)
+                                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                      parsePrimary(=>, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(=>)
                                                           listener: handleLiteralInt(0)
                                                 listener: handleExpressionFunctionBody(=>, null)
@@ -109,9 +109,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_guarded.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_guarded.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_guarded.dart.intertwined.expect
index 82e939b..50a7c88 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_guarded.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_guarded.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -77,9 +77,9 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
                               inPlainSync()
                               parseSwitchExpression(when)
                                 listener: beginSwitchExpression(switch)
@@ -89,9 +89,9 @@
                                       looksLikeOuterPatternEquals(()
                                         skipOuterPattern(()
                                           skipObjectPatternRest(x)
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -115,19 +115,19 @@
                                 parseExpression(when)
                                   looksLikeOuterPatternEquals(when)
                                     skipOuterPattern(when)
-                                  parsePrecedenceExpression(when, 1, true)
-                                    parseUnaryExpression(when, true)
-                                      parsePrimary(when, expression)
+                                  parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(when, true, ConstantPatternContext.none)
+                                      parsePrimary(when, expression, ConstantPatternContext.none)
                                         parseLiteralBool(when)
                                           listener: handleLiteralBool(true)
                                 ensureFunctionArrow(true)
                                 parseExpression(=>)
                                   looksLikeOuterPatternEquals(=>)
                                     skipOuterPattern(=>)
-                                  parsePrecedenceExpression(=>, 1, true)
-                                    parseUnaryExpression(=>, true)
-                                      parsePrimary(=>, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
+                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                      parsePrimary(=>, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
                                           listener: handleNoTypeVariables(()
                                           parseFunctionExpression(=>)
                                             listener: beginFunctionExpression(()
@@ -144,9 +144,9 @@
                                                   parseExpression(=>)
                                                     looksLikeOuterPatternEquals(=>)
                                                       skipOuterPattern(=>)
-                                                    parsePrecedenceExpression(=>, 1, true)
-                                                      parseUnaryExpression(=>, true)
-                                                        parsePrimary(=>, expression)
+                                                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                        parsePrimary(=>, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(=>)
                                                             listener: handleLiteralInt(0)
                                                   listener: handleExpressionFunctionBody(=>, null)
@@ -159,9 +159,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_unguarded.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_unguarded.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_unguarded.dart.intertwined.expect
index eee4631..e43668d 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_unguarded.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionCase_unguarded.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -77,9 +77,9 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
                               inPlainSync()
                               parseSwitchExpression(when)
                                 listener: beginSwitchExpression(switch)
@@ -89,9 +89,9 @@
                                       looksLikeOuterPatternEquals(()
                                         skipOuterPattern(()
                                           skipObjectPatternRest(x)
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -116,10 +116,10 @@
                                 parseExpression(=>)
                                   looksLikeOuterPatternEquals(=>)
                                     skipOuterPattern(=>)
-                                  parsePrecedenceExpression(=>, 1, true)
-                                    parseUnaryExpression(=>, true)
-                                      parsePrimary(=>, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
+                                  parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                      parsePrimary(=>, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
                                           listener: handleNoTypeVariables(()
                                           parseFunctionExpression(=>)
                                             listener: beginFunctionExpression(()
@@ -136,9 +136,9 @@
                                                   parseExpression(=>)
                                                     looksLikeOuterPatternEquals(=>)
                                                       skipOuterPattern(=>)
-                                                    parsePrecedenceExpression(=>, 1, true)
-                                                      parseUnaryExpression(=>, true)
-                                                        parsePrimary(=>, expression)
+                                                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                        parsePrimary(=>, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(=>)
                                                             listener: handleLiteralInt(0)
                                                   listener: handleExpressionFunctionBody(=>, null)
@@ -151,9 +151,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionScrutinee.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionScrutinee.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionScrutinee.dart.intertwined.expect
index bd83ea2..b15d6f4 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionScrutinee.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchExpressionScrutinee.dart.intertwined.expect
@@ -29,9 +29,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -40,10 +40,10 @@
                           parseExpression(()
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
-                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                     listener: handleNoTypeVariables(()
                                     parseFunctionExpression(()
                                       listener: beginFunctionExpression(()
@@ -60,9 +60,9 @@
                                             parseExpression(=>)
                                               looksLikeOuterPatternEquals(=>)
                                                 skipOuterPattern(=>)
-                                              parsePrecedenceExpression(=>, 1, true)
-                                                parseUnaryExpression(=>, true)
-                                                  parsePrimary(=>, expression)
+                                              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                  parsePrimary(=>, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(=>)
                                                       listener: handleLiteralInt(0)
                                             listener: handleExpressionFunctionBody(=>, null)

pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchStatementInWhenClause.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchStatementInWhenClause.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchStatementInWhenClause.dart.intertwined.expect
index b9700ee..9406879 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchStatementInWhenClause.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_allowed_insideSwitchStatementInWhenClause.dart.intertwined.expect
@@ -57,9 +57,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -87,9 +87,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(y)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
                               isNextIdentifier(when)
@@ -100,10 +100,10 @@
                                 listener: handleNoArguments(+)
                               listener: handleSend(y, +)
                       listener: beginBinaryExpression(+)
-                      parsePrecedenceExpression(+, 14, true)
-                        parseUnaryExpression(+, true)
-                          parsePrimary(+, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+)
+                      parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                        parseUnaryExpression(+, true, ConstantPatternContext.none)
+                          parsePrimary(+, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(+)
                                 listener: beginFunctionExpression(()
@@ -120,9 +120,9 @@
                                       parseExpression(=>)
                                         looksLikeOuterPatternEquals(=>)
                                           skipOuterPattern(=>)
-                                        parsePrecedenceExpression(=>, 1, true)
-                                          parseUnaryExpression(=>, true)
-                                            parsePrimary(=>, expression)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                               parseLiteralInt(=>)
                                                 listener: handleLiteralInt(0)
                                       listener: handleExpressionFunctionBody(=>, null)

pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterListPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterListPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterListPattern.dart.intertwined.expect
index 4c8cdd1..5184929 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterListPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterListPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -82,11 +82,11 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when)
-                                parseParenthesizedExpressionOrRecordLiteral(when, null)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(when, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureCloseParen((, ()
                                   listener: endRecordLiteral((, 0, null)
@@ -94,9 +94,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterMapPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterMapPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterMapPattern.dart.intertwined.expect
index e61e6bd..7f66a2d 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterMapPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterMapPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -75,9 +75,9 @@
                             parseExpression({)
                               looksLikeOuterPatternEquals({)
                                 skipOuterPattern({)
-                              parsePrecedenceExpression({, 1, true)
-                                parseUnaryExpression({, true)
-                                  parsePrimary({, expression)
+                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                  parsePrimary({, expression, ConstantPatternContext.none)
                                     parseLiteralString({)
                                       parseSingleLiteralString({)
                                         listener: beginLiteralString('x')
@@ -93,11 +93,11 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when)
-                                parseParenthesizedExpressionOrRecordLiteral(when, null)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(when, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureCloseParen((, ()
                                   listener: endRecordLiteral((, 0, null)
@@ -105,9 +105,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterObjectPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterObjectPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterObjectPattern.dart.intertwined.expect
index 8b6da33..255eeb2 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterObjectPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterObjectPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -86,11 +86,11 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when)
-                                parseParenthesizedExpressionOrRecordLiteral(when, null)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(when, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureCloseParen((, ()
                                   listener: endRecordLiteral((, 0, null)
@@ -98,9 +98,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterParenthesizedPattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterParenthesizedPattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterParenthesizedPattern.dart.intertwined.expect
index 6153d84..b809efd 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterParenthesizedPattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterParenthesizedPattern.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -82,11 +82,11 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when)
-                                parseParenthesizedExpressionOrRecordLiteral(when, null)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(when, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(when, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureCloseParen((, ()
                                   listener: endRecordLiteral((, 0, null)
@@ -94,9 +94,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterSwitchExpressionInWhenClause.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterSwitchExpressionInWhenClause.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterSwitchExpressionInWhenClause.dart.intertwined.expect
index 3a8afbf..c18317b 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterSwitchExpressionInWhenClause.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_afterSwitchExpressionInWhenClause.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -77,9 +77,9 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
                               inPlainSync()
                               parseSwitchExpression(when)
                                 listener: beginSwitchExpression(switch)
@@ -89,9 +89,9 @@
                                       looksLikeOuterPatternEquals(()
                                         skipOuterPattern(()
                                           skipObjectPatternRest(x)
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -108,11 +108,11 @@
                                 listener: endSwitchExpressionBlock(0, {, })
                                 listener: endSwitchExpression(switch, })
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+)
-                                  parseParenthesizedExpressionOrRecordLiteral(+, null)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(+, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen((, ()
                                     listener: endRecordLiteral((, 0, null)
@@ -121,9 +121,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_insideSwitchExpressionInWhenClause.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_insideSwitchExpressionInWhenClause.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_insideSwitchExpressionInWhenClause.dart.intertwined.expect
index 717d504..cea15e3 100644
--- a/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_insideSwitchExpressionInWhenClause.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/functionExpression_disallowed_insideSwitchExpressionInWhenClause.dart.intertwined.expect
@@ -49,9 +49,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -61,9 +61,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -88,9 +88,9 @@
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
                             skipObjectPatternRest(y)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(when, expression)
                                 parseSend(when, expression)
                                   isNextIdentifier(when)
@@ -101,11 +101,11 @@
                                     listener: handleNoArguments(+)
                                   listener: handleSend(y, +)
                           listener: beginBinaryExpression(+)
-                          parsePrecedenceExpression(+, 14, true)
-                            parseUnaryExpression(+, true)
-                              parsePrimary(+, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+)
-                                  parseParenthesizedExpressionOrRecordLiteral(+, null)
+                          parsePrecedenceExpression(+, 14, true, ConstantPatternContext.none)
+                            parseUnaryExpression(+, true, ConstantPatternContext.none)
+                              parsePrimary(+, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(+, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(+, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen((, ()
                                     listener: endRecordLiteral((, 0, null)
@@ -114,9 +114,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/integer_literal_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_case.dart.intertwined.expect
index 94d8d8a..47f3c65 100644
--- a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/integer_literal_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_cast.dart.intertwined.expect
index 15d18cf..b7f009c 100644
--- a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/integer_literal_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_if_case.dart.intertwined.expect
index 21381e3..2f8b1da 100644
--- a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(case)
                                 listener: handleLiteralInt(1)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_assert.dart.intertwined.expect
index 2da577c..65e7f60 100644
--- a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_check.dart.intertwined.expect
index 4db617c..1b7db47 100644
--- a/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/integer_literal_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/issue50591.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/issue50591.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/issue50591.dart.intertwined.expect
index 641bcec..43d4bc6 100644
--- a/pkg/front_end/parser_testcases/patterns/issue50591.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/issue50591.dart.intertwined.expect
@@ -59,9 +59,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -71,9 +71,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -98,9 +98,9 @@
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
                             skipObjectPatternRest(a)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(when, expression)
                                 parseSend(when, expression)
                                   isNextIdentifier(when)
@@ -117,9 +117,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/issue50591_example2.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/issue50591_example2.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/issue50591_example2.dart.intertwined.expect
index 0e7ae2e..4422dbe 100644
--- a/pkg/front_end/parser_testcases/patterns/issue50591_example2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/issue50591_example2.dart.intertwined.expect
@@ -47,18 +47,18 @@
                     parseExpression({)
                       looksLikeOuterPatternEquals({)
                         skipOuterPattern({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         inPlainSync()
                                         parseSwitchExpression(()
                                           listener: beginSwitchExpression(switch)
@@ -68,9 +68,9 @@
                                                 looksLikeOuterPatternEquals(()
                                                   skipOuterPattern(()
                                                     skipObjectPatternRest(x)
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()
@@ -88,9 +88,9 @@
                                           parsePattern({, PatternContext.matching, precedence: 1)
                                             parsePrimaryPattern({, PatternContext.matching)
                                               listener: beginConstantPattern(const)
-                                              parsePrecedenceExpression(const, 17, false)
-                                                parseUnaryExpression(const, false)
-                                                  parsePrimary(const, expression)
+                                              parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                                                parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                                  parsePrimary(const, expression, ConstantPatternContext.explicit)
                                                     parseSendOrFunctionLiteral(const, expression)
                                                       parseSend(const, expression)
                                                         isNextIdentifier(const)
@@ -109,9 +109,9 @@
                                           parseExpression(=>)
                                             looksLikeOuterPatternEquals(=>)
                                               skipOuterPattern(=>)
-                                            parsePrecedenceExpression(=>, 1, true)
-                                              parseUnaryExpression(=>, true)
-                                                parsePrimary(=>, expression)
+                                            parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                parsePrimary(=>, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(=>)
                                                     listener: handleLiteralInt(0)
                                           listener: endSwitchExpressionCase(null, =>, 0)
@@ -126,9 +126,9 @@
                                           parseExpression(=>)
                                             looksLikeOuterPatternEquals(=>)
                                               skipOuterPattern(=>)
-                                            parsePrecedenceExpression(=>, 1, true)
-                                              parseUnaryExpression(=>, true)
-                                                parsePrimary(=>, expression)
+                                            parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                parsePrimary(=>, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(=>)
                                                     listener: handleLiteralInt(1)
                                           listener: endSwitchExpressionCase(null, =>, 1)

pkg/front_end/parser_testcases/patterns/issue_51169.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/issue_51169.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/issue_51169.dart.intertwined.expect
index 8864624..39298b9 100644
--- a/pkg/front_end/parser_testcases/patterns/issue_51169.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/issue_51169.dart.intertwined.expect
@@ -131,9 +131,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(a)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -171,9 +171,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(b)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
                               isNextIdentifier(when)
@@ -184,9 +184,9 @@
                                 listener: handleNoArguments(!=)
                               listener: handleSend(b, !=)
                       listener: beginBinaryExpression(!=)
-                      parsePrecedenceExpression(!=, 8, true)
-                        parseUnaryExpression(!=, true)
-                          parsePrimary(!=, expression)
+                      parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                        parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                          parsePrimary(!=, expression, ConstantPatternContext.none)
                             parseLiteralInt(!=)
                               listener: handleLiteralInt(2)
                       listener: endBinaryExpression(!=)
@@ -205,9 +205,9 @@
                               looksLikeOuterPatternEquals(:)
                                 skipOuterPattern(:)
                                   skipObjectPatternRest(print)
-                              parsePrecedenceExpression(:, 1, true)
-                                parseUnaryExpression(:, true)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(:, expression)
                                       looksLikeFunctionBody(;)
                                       parseSend(:, expression)
@@ -223,9 +223,9 @@
                                                 looksLikeOuterPatternEquals(()
                                                   skipOuterPattern(()
                                                     skipObjectPatternRest(b)
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()
@@ -284,9 +284,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(b)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
                               isNextIdentifier(when)
@@ -297,26 +297,26 @@
                                 listener: handleNoArguments(!=)
                               listener: handleSend(b, !=)
                       listener: beginBinaryExpression(!=)
-                      parsePrecedenceExpression(!=, 8, true)
-                        parseUnaryExpression(!=, true)
-                          parsePrimary(!=, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!=)
-                              parseParenthesizedExpressionOrRecordLiteral(!=, null)
+                      parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                        parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                          parsePrimary(!=, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!=, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(!=, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(2)
                                 parseExpression(,)
                                   looksLikeOuterPatternEquals(,)
                                     skipOuterPattern(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(3)
                                 ensureCloseParen(3, ()
@@ -337,9 +337,9 @@
                               looksLikeOuterPatternEquals(:)
                                 skipOuterPattern(:)
                                   skipObjectPatternRest(print)
-                              parsePrecedenceExpression(:, 1, true)
-                                parseUnaryExpression(:, true)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(:, expression)
                                       looksLikeFunctionBody(;)
                                       parseSend(:, expression)
@@ -355,9 +355,9 @@
                                                 looksLikeOuterPatternEquals(()
                                                   skipOuterPattern(()
                                                     skipObjectPatternRest(b)
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()
@@ -397,9 +397,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(b)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
                               isNextIdentifier(when)
@@ -410,9 +410,9 @@
                                 listener: handleNoArguments(!=)
                               listener: handleSend(b, !=)
                       listener: beginBinaryExpression(!=)
-                      parsePrecedenceExpression(!=, 8, true)
-                        parseUnaryExpression(!=, true)
-                          parsePrimary(!=, expression)
+                      parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                        parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                          parsePrimary(!=, expression, ConstantPatternContext.none)
                             parseLiteralInt(!=)
                               listener: handleLiteralInt(2)
                       listener: endBinaryExpression(!=)
@@ -431,9 +431,9 @@
                               looksLikeOuterPatternEquals(:)
                                 skipOuterPattern(:)
                                   skipObjectPatternRest(print)
-                              parsePrecedenceExpression(:, 1, true)
-                                parseUnaryExpression(:, true)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(:, expression)
                                       looksLikeFunctionBody(;)
                                       parseSend(:, expression)
@@ -449,9 +449,9 @@
                                                 looksLikeOuterPatternEquals(()
                                                   skipOuterPattern(()
                                                     skipObjectPatternRest(b)
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()
@@ -511,9 +511,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(b)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
                               isNextIdentifier(when)
@@ -524,26 +524,26 @@
                                 listener: handleNoArguments(!=)
                               listener: handleSend(b, !=)
                       listener: beginBinaryExpression(!=)
-                      parsePrecedenceExpression(!=, 8, true)
-                        parseUnaryExpression(!=, true)
-                          parsePrimary(!=, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!=)
-                              parseParenthesizedExpressionOrRecordLiteral(!=, null)
+                      parsePrecedenceExpression(!=, 8, true, ConstantPatternContext.none)
+                        parseUnaryExpression(!=, true, ConstantPatternContext.none)
+                          parsePrimary(!=, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(!=, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(!=, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
                                     skipOuterPattern(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(2)
                                 parseExpression(,)
                                   looksLikeOuterPatternEquals(,)
                                     skipOuterPattern(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(3)
                                 ensureCloseParen(3, ()
@@ -564,9 +564,9 @@
                               looksLikeOuterPatternEquals(:)
                                 skipOuterPattern(:)
                                   skipObjectPatternRest(print)
-                              parsePrecedenceExpression(:, 1, true)
-                                parseUnaryExpression(:, true)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(:, expression)
                                       looksLikeFunctionBody(;)
                                       parseSend(:, expression)
@@ -582,9 +582,9 @@
                                                 looksLikeOuterPatternEquals(()
                                                   skipOuterPattern(()
                                                     skipObjectPatternRest(b)
-                                                parsePrecedenceExpression((, 1, true)
-                                                  parseUnaryExpression((, true)
-                                                    parsePrimary((, expression)
+                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                       parseSendOrFunctionLiteral((, expression)
                                                         parseSend((, expression)
                                                           isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/issue_51176.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/issue_51176.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/issue_51176.dart.intertwined.expect
index 5ca47cf..2fa3d1f 100644
--- a/pkg/front_end/parser_testcases/patterns/issue_51176.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/issue_51176.dart.intertwined.expect
@@ -54,29 +54,29 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
                                 looksLikeOuterPatternEquals(()
                                   skipOuterPattern(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                        parseParenthesizedExpressionOrRecordLiteral((, null)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
                                             looksLikeOuterPatternEquals(()
                                               skipOuterPattern(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -118,31 +118,31 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
@@ -211,42 +211,42 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -256,29 +256,29 @@
                               parseExpression(,)
                                 looksLikeOuterPatternEquals(,)
                                   skipOuterPattern(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                        parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(y, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(1)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(,)
                                                     listener: handleLiteralInt(0)
                                           ensureCloseParen(0, ()
@@ -315,29 +315,29 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
                                 looksLikeOuterPatternEquals(()
                                   skipOuterPattern(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                        parseParenthesizedExpressionOrRecordLiteral((, null)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
                                             looksLikeOuterPatternEquals(()
                                               skipOuterPattern(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -379,31 +379,31 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
@@ -472,42 +472,42 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -517,29 +517,29 @@
                               parseExpression(,)
                                 looksLikeOuterPatternEquals(,)
                                   skipOuterPattern(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                        parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(y, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(1)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(,)
                                                     listener: handleLiteralInt(0)
                                           ensureCloseParen(0, ()
@@ -578,29 +578,29 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
                                 looksLikeOuterPatternEquals(()
                                   skipOuterPattern(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                        parseParenthesizedExpressionOrRecordLiteral((, null)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
                                             looksLikeOuterPatternEquals(()
                                               skipOuterPattern(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -644,31 +644,31 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
@@ -745,42 +745,42 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -790,29 +790,29 @@
                               parseExpression(,)
                                 looksLikeOuterPatternEquals(,)
                                   skipOuterPattern(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                        parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(y, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(1)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(,)
                                                     listener: handleLiteralInt(0)
                                           ensureCloseParen(0, ()
@@ -906,42 +906,42 @@
                   parseExpression(=)
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               ensureIdentifier((, namedRecordFieldReference)
                                 listener: handleIdentifier(n, namedRecordFieldReference)
                               parseExpression(:)
                                 looksLikeOuterPatternEquals(:)
                                   skipOuterPattern(:)
-                                parsePrecedenceExpression(:, 1, true)
-                                  parseUnaryExpression(:, true)
-                                    parsePrimary(:, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                                        parseParenthesizedExpressionOrRecordLiteral(:, null)
+                                parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                    parsePrimary(:, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(x, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(42)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrecedenceExpression(-, 16, true)
-                                                  parseUnaryExpression(-, true)
-                                                    parsePrimary(-, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrecedenceExpression(-, 16, true, ConstantPatternContext.none)
+                                                  parseUnaryExpression(-, true, ConstantPatternContext.none)
+                                                    parsePrimary(-, expression, ConstantPatternContext.none)
                                                       parseLiteralInt(-)
                                                         listener: handleLiteralInt(1)
                                                 listener: handleUnaryPrefixExpression(-)
@@ -951,29 +951,29 @@
                               parseExpression(,)
                                 looksLikeOuterPatternEquals(,)
                                   skipOuterPattern(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                        parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           ensureIdentifier((, namedRecordFieldReference)
                                             listener: handleIdentifier(y, namedRecordFieldReference)
                                           parseExpression(:)
                                             looksLikeOuterPatternEquals(:)
                                               skipOuterPattern(:)
-                                            parsePrecedenceExpression(:, 1, true)
-                                              parseUnaryExpression(:, true)
-                                                parsePrimary(:, expression)
+                                            parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                                parsePrimary(:, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(:)
                                                     listener: handleLiteralInt(1)
                                           listener: handleNamedRecordField(:)
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(,)
                                                     listener: handleLiteralInt(0)
                                           ensureCloseParen(0, ()

pkg/front_end/parser_testcases/patterns/issue_51230.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/issue_51230.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/issue_51230.dart.intertwined.expect
index 80159ee..63435ca 100644
--- a/pkg/front_end/parser_testcases/patterns/issue_51230.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/issue_51230.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(o)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -80,9 +80,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -101,9 +101,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -122,9 +122,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -163,9 +163,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -185,9 +185,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -207,9 +207,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -229,9 +229,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -271,9 +271,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -299,9 +299,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -347,9 +347,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -376,9 +376,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -405,9 +405,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -434,9 +434,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -483,9 +483,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -502,9 +502,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('')
@@ -554,9 +554,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -566,9 +566,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(o)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -595,9 +595,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -616,9 +616,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -637,9 +637,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -678,9 +678,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -700,9 +700,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -722,9 +722,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -744,9 +744,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -786,9 +786,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -814,9 +814,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -862,9 +862,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -891,9 +891,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -920,9 +920,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -949,9 +949,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -998,9 +998,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('working')
@@ -1017,9 +1017,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralString(=>)
                                 parseSingleLiteralString(=>)
                                   listener: beginLiteralString('')
@@ -1065,10 +1065,10 @@
                     parseExpression({)
                       looksLikeOuterPatternEquals({)
                         skipOuterPattern({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression({)
                                 listener: beginFunctionExpression(()
@@ -1086,9 +1086,9 @@
                                         looksLikeOuterPatternEquals(=>)
                                           skipOuterPattern(=>)
                                             skipObjectPatternRest(print)
-                                        parsePrecedenceExpression(=>, 1, true)
-                                          parseUnaryExpression(=>, true)
-                                            parsePrimary(=>, expression)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(=>, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend(=>, expression)
@@ -1103,9 +1103,9 @@
                                                         parseExpression(()
                                                           looksLikeOuterPatternEquals(()
                                                             skipOuterPattern(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("async unnamed taking 0 parameters")
@@ -1127,10 +1127,10 @@
                     parseExpression(;)
                       looksLikeOuterPatternEquals(;)
                         skipOuterPattern(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(;)
                                 listener: beginFunctionExpression(()
@@ -1160,9 +1160,9 @@
                                         looksLikeOuterPatternEquals(=>)
                                           skipOuterPattern(=>)
                                             skipObjectPatternRest(print)
-                                        parsePrecedenceExpression(=>, 1, true)
-                                          parseUnaryExpression(=>, true)
-                                            parsePrimary(=>, expression)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(=>, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend(=>, expression)
@@ -1177,9 +1177,9 @@
                                                         parseExpression(()
                                                           looksLikeOuterPatternEquals(()
                                                             skipOuterPattern(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("async unnamed taking 1 parameter")
@@ -1201,10 +1201,10 @@
                     parseExpression(;)
                       looksLikeOuterPatternEquals(;)
                         skipOuterPattern(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(;)
                                 listener: beginFunctionExpression(()
@@ -1246,9 +1246,9 @@
                                         looksLikeOuterPatternEquals(=>)
                                           skipOuterPattern(=>)
                                             skipObjectPatternRest(print)
-                                        parsePrecedenceExpression(=>, 1, true)
-                                          parseUnaryExpression(=>, true)
-                                            parsePrimary(=>, expression)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(=>, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend(=>, expression)
@@ -1263,9 +1263,9 @@
                                                         parseExpression(()
                                                           looksLikeOuterPatternEquals(()
                                                             skipOuterPattern(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("async unnamed taking 2 parameters")

pkg/front_end/parser_testcases/patterns/list_insideAssignment_typed_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_typed_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_typed_nonEmpty.dart.intertwined.expect
index edc3cbe..b1fdaaf 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_typed_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_typed_nonEmpty.dart.intertwined.expect
@@ -69,9 +69,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_empty.dart.intertwined.expect
index 6e5150e..664a4a0 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_empty.dart.intertwined.expect
@@ -58,9 +58,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_emptyWithWhitespace.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_emptyWithWhitespace.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_emptyWithWhitespace.dart.intertwined.expect
index 167ef33..3165dee 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_emptyWithWhitespace.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_emptyWithWhitespace.dart.intertwined.expect
@@ -55,9 +55,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_nonEmpty.dart.intertwined.expect
index 130bfe6..8d93a3e 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideAssignment_untyped_nonEmpty.dart.intertwined.expect
@@ -65,9 +65,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideDeclaration_typed_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_typed_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_typed_nonEmpty.dart.intertwined.expect
index e4b1685..4467b49 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_typed_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_typed_nonEmpty.dart.intertwined.expect
@@ -66,9 +66,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_empty.dart.intertwined.expect
index 30f3472..1c35703 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_empty.dart.intertwined.expect
@@ -55,9 +55,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_emptyWithWhitespace.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_emptyWithWhitespace.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_emptyWithWhitespace.dart.intertwined.expect
index ddb8436..2a5a82c 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_emptyWithWhitespace.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_emptyWithWhitespace.dart.intertwined.expect
@@ -52,9 +52,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect
index 7f4fa2b..212d5cd 100644
--- a/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect
@@ -62,9 +62,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/list_pattern_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case.dart.intertwined.expect
index f55866e..0009ccd 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,18 +76,18 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty.dart.intertwined.expect
index 8d7de71..9bf8c0a 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.intertwined.expect
index 75fed97..625a744 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_empty_whitespace.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.intertwined.expect
index 2b43816..7c5e70d 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_case_with_type_arguments.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -80,18 +80,18 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/list_pattern_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_cast.dart.intertwined.expect
index ae89a1d..6a87d54 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_assert.dart.intertwined.expect
index e4d14e8..784db19 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_check.dart.intertwined.expect
index 8998a9a..b66540b 100644
--- a/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/list_pattern_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/logical_and_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/logical_and_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/logical_and_inside_if_case.dart.intertwined.expect
index 7f54f3e..07d91c4 100644
--- a/pkg/front_end/parser_testcases/patterns/logical_and_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/logical_and_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_and_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_and_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_and_lhs.dart.intertwined.expect
index 28c44e2..6defc47 100644
--- a/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_and_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_and_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_lhs.dart.intertwined.expect
index 4624317..08615af 100644
--- a/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_rhs.dart.intertwined.expect
index 917d3fe..c9fef77 100644
--- a/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/logical_and_inside_logical_or_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/logical_or_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/logical_or_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/logical_or_inside_if_case.dart.intertwined.expect
index 90a7bfb..648ea46 100644
--- a/pkg/front_end/parser_testcases/patterns/logical_or_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/logical_or_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/logical_or_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/logical_or_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/logical_or_inside_logical_or_lhs.dart.intertwined.expect
index 9514a75..1395f85 100644
--- a/pkg/front_end/parser_testcases/patterns/logical_or_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/logical_or_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/map_insideAssignment_typed_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_typed_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_typed_nonEmpty.dart.intertwined.expect
index 2258fb0..44c8f6b 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_typed_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_typed_nonEmpty.dart.intertwined.expect
@@ -60,9 +60,9 @@
                               parseExpression({)
                                 looksLikeOuterPatternEquals({)
                                   skipOuterPattern({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseLiteralString({)
                                         parseSingleLiteralString({)
                                           listener: beginLiteralString('a')
@@ -76,9 +76,9 @@
                               parseExpression(,)
                                 looksLikeOuterPatternEquals(,)
                                   skipOuterPattern(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralString(,)
                                         parseSingleLiteralString(,)
                                           listener: beginLiteralString('b')
@@ -94,9 +94,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty.dart.intertwined.expect
index 537011c..8aba6be 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty.dart.intertwined.expect
@@ -45,11 +45,11 @@
                     parseExpression({)
                       looksLikeOuterPatternEquals({)
                         skipOuterPattern({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
@@ -64,9 +64,9 @@
                                       looksLikeOuterPatternEquals(=)
                                         skipOuterPattern(=)
                                           skipObjectPatternRest(x)
-                                      parsePrecedenceExpression(=, 1, true)
-                                        parseUnaryExpression(=, true)
-                                          parsePrimary(=, expression)
+                                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                          parsePrimary(=, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(=, expression)
                                               parseSend(=, expression)
                                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty_beginningOfStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty_beginningOfStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty_beginningOfStatement.dart.intertwined.expect
index be77126..0af759f 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty_beginningOfStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_empty_beginningOfStatement.dart.intertwined.expect
@@ -52,9 +52,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty.dart.intertwined.expect
index cf8b2e0..71eeeea 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty.dart.intertwined.expect
@@ -45,11 +45,11 @@
                     parseExpression({)
                       looksLikeOuterPatternEquals({)
                         skipOuterPattern({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
                                   looksLikeOuterPatternEquals(()
@@ -62,9 +62,9 @@
                                           parseExpression({)
                                             looksLikeOuterPatternEquals({)
                                               skipOuterPattern({)
-                                            parsePrecedenceExpression({, 1, true)
-                                              parseUnaryExpression({, true)
-                                                parsePrimary({, expression)
+                                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                parsePrimary({, expression, ConstantPatternContext.none)
                                                   parseLiteralString({)
                                                     parseSingleLiteralString({)
                                                       listener: beginLiteralString('a')
@@ -78,9 +78,9 @@
                                           parseExpression(,)
                                             looksLikeOuterPatternEquals(,)
                                               skipOuterPattern(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralString(,)
                                                     parseSingleLiteralString(,)
                                                       listener: beginLiteralString('b')
@@ -96,9 +96,9 @@
                                       looksLikeOuterPatternEquals(=)
                                         skipOuterPattern(=)
                                           skipObjectPatternRest(x)
-                                      parsePrecedenceExpression(=, 1, true)
-                                        parseUnaryExpression(=, true)
-                                          parsePrimary(=, expression)
+                                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                                          parsePrimary(=, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral(=, expression)
                                               parseSend(=, expression)
                                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty_beginningOfStatement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty_beginningOfStatement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty_beginningOfStatement.dart.intertwined.expect
index fbe6ce6..8e1dc17 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty_beginningOfStatement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideAssignment_untyped_nonEmpty_beginningOfStatement.dart.intertwined.expect
@@ -50,9 +50,9 @@
                           parseExpression({)
                             looksLikeOuterPatternEquals({)
                               skipOuterPattern({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseLiteralString({)
                                     parseSingleLiteralString({)
                                       listener: beginLiteralString('a')
@@ -66,9 +66,9 @@
                           parseExpression(,)
                             looksLikeOuterPatternEquals(,)
                               skipOuterPattern(,)
-                            parsePrecedenceExpression(,, 1, true)
-                              parseUnaryExpression(,, true)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                parsePrimary(,, expression, ConstantPatternContext.none)
                                   parseLiteralString(,)
                                     parseSingleLiteralString(,)
                                       listener: beginLiteralString('b')
@@ -84,9 +84,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideDeclaration_typed_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_typed_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_typed_nonEmpty.dart.intertwined.expect
index 473cc3d..24730ec 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_typed_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_typed_nonEmpty.dart.intertwined.expect
@@ -57,9 +57,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -73,9 +73,9 @@
                         parseExpression(,)
                           looksLikeOuterPatternEquals(,)
                             skipOuterPattern(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString('b')
@@ -91,9 +91,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_empty.dart.intertwined.expect
index 8877636..11dcd0d 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_empty.dart.intertwined.expect
@@ -52,9 +52,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect
index b19d2bc..d7150c9 100644
--- a/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_insideDeclaration_untyped_nonEmpty.dart.intertwined.expect
@@ -50,9 +50,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -66,9 +66,9 @@
                         parseExpression(,)
                           looksLikeOuterPatternEquals(,)
                             skipOuterPattern(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString('b')
@@ -84,9 +84,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/map_pattern_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case.dart.intertwined.expect
index 0922161..3f4a641 100644
--- a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -96,9 +96,9 @@
                         parseExpression(,)
                           looksLikeOuterPatternEquals(,)
                             skipOuterPattern(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString('b')
@@ -106,9 +106,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_empty.dart.intertwined.expect
index 0a3eea1..bbf4a41 100644
--- a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_empty.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.intertwined.expect
index 54c5ce2..6f272de 100644
--- a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_case_with_type_arguments.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -83,9 +83,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -93,9 +93,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -103,9 +103,9 @@
                         parseExpression(,)
                           looksLikeOuterPatternEquals(,)
                             skipOuterPattern(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString('b')
@@ -113,9 +113,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/map_pattern_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_cast.dart.intertwined.expect
index 5fbdb5a..5a05bae 100644
--- a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_assert.dart.intertwined.expect
index 77903a2..da18c06 100644
--- a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_check.dart.intertwined.expect
index 15b2074..1339a50 100644
--- a/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/map_pattern_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_case.dart.intertwined.expect
index ad54182..35381ad 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_case.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern.dart.intertwined.expect
index 3184fb2..cca3618 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -122,9 +122,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
index 466cc7a..525daab 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/null_assert_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_if_case.dart.intertwined.expect
index d946278..6a67e73 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/null_assert_inside_list_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_list_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_list_pattern.dart.intertwined.expect
index 6841e31..f3a1593 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_list_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_list_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_lhs.dart.intertwined.expect
index 73b59ca..ae70029 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -83,9 +83,9 @@
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(&&, 17, false)
-                          parseUnaryExpression(&&, false)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
+                            parsePrimary(&&, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(&&)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_rhs.dart.intertwined.expect
index afe108c..be81ef4 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_and_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -82,9 +82,9 @@
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(&&, 17, false)
-                          parseUnaryExpression(&&, false)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
+                            parsePrimary(&&, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(&&)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_lhs.dart.intertwined.expect
index 5288210..fb28020 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -83,9 +83,9 @@
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(||, 17, false)
-                          parseUnaryExpression(||, false)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(||, false, ConstantPatternContext.implicit)
+                            parsePrimary(||, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(||)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_rhs.dart.intertwined.expect
index 644fc41..4d296ec 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_logical_or_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -82,9 +82,9 @@
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(||, 17, false)
-                          parseUnaryExpression(||, false)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(||, false, ConstantPatternContext.implicit)
+                            parsePrimary(||, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(||)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_map_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_map_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_map_pattern.dart.intertwined.expect
index 9313cc8..740f980 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_map_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_map_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_parenthesized_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_parenthesized_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_parenthesized_pattern.dart.intertwined.expect
index f3603e4..34d9556 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_parenthesized_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_parenthesized_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.intertwined.expect
index 1178adb..9fc9fa8 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_implicitly_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -83,9 +83,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_named.dart.intertwined.expect
index be7f71c..00e8542 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -77,9 +77,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -88,9 +88,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.intertwined.expect
index 7ee9a42..5abe479 100644
--- a/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_assert_inside_record_pattern_unnamed.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -86,9 +86,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_case.dart.intertwined.expect
index 231a465..cb4eee9 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_case.dart.intertwined.expect
@@ -58,9 +58,9 @@
                         parseExpression(=)
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseLiteralInt(=)
                                   listener: handleLiteralInt(1)
                         listener: endVariableInitializer(=)
@@ -78,9 +78,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -101,9 +101,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseSendOrFunctionLiteral(case, expression)
                               parseSend(case, expression)
                                 isNextIdentifier(case)

pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern.dart.intertwined.expect
index 53176a9..42b70d08 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -122,9 +122,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
index 3737d26..ac695d7 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/null_check_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_if_case.dart.intertwined.expect
index c7d077b..95892ad 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/null_check_inside_list_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_list_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_list_pattern.dart.intertwined.expect
index f1ae60f..aabe904 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_list_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_list_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression([, 17, false)
-                              parseUnaryExpression([, false)
-                                parsePrimary([, expression)
+                            parsePrecedenceExpression([, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression([, false, ConstantPatternContext.implicit)
+                                parsePrimary([, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt([)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_lhs.dart.intertwined.expect
index 1f4ad0e..e70a59c 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -83,9 +83,9 @@
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(&&, 17, false)
-                          parseUnaryExpression(&&, false)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
+                            parsePrimary(&&, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(&&)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_rhs.dart.intertwined.expect
index c77d0e0..39a380b 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_and_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -82,9 +82,9 @@
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(&&, 17, false)
-                          parseUnaryExpression(&&, false)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
+                            parsePrimary(&&, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(&&)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_lhs.dart.intertwined.expect
index 0549c6a..a240164 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -83,9 +83,9 @@
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(||, 17, false)
-                          parseUnaryExpression(||, false)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(||, false, ConstantPatternContext.implicit)
+                            parsePrimary(||, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(||)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_rhs.dart.intertwined.expect
index 17362f8..5e34464 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_logical_or_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
@@ -82,9 +82,9 @@
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(||, 17, false)
-                          parseUnaryExpression(||, false)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(||, false, ConstantPatternContext.implicit)
+                            parsePrimary(||, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(||)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_map_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_map_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_map_pattern.dart.intertwined.expect
index 9a275d1..0b1afff 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_map_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_map_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -86,9 +86,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_parenthesized_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_parenthesized_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_parenthesized_pattern.dart.intertwined.expect
index faf99a1..d2b10f7 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_parenthesized_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_parenthesized_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.intertwined.expect
index fb7b739..93b47fb 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_implicitly_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -83,9 +83,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_named.dart.intertwined.expect
index 3265b82..309f954 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -77,9 +77,9 @@
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(:, 17, false)
-                              parseUnaryExpression(:, false)
-                                parsePrimary(:, expression)
+                            parsePrecedenceExpression(:, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(:, false, ConstantPatternContext.implicit)
+                                parsePrimary(:, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(:)
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -88,9 +88,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_unnamed.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_unnamed.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_unnamed.dart.intertwined.expect
index 1e06a0e..52c42cd 100644
--- a/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_unnamed.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_check_inside_record_pattern_unnamed.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -86,9 +86,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_literal_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_literal_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_literal_inside_case.dart.intertwined.expect
index 7fb2d2a8..1897bbc 100644
--- a/pkg/front_end/parser_testcases/patterns/null_literal_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_literal_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralNull(case)
                               listener: handleLiteralNull(null)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_literal_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_literal_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_literal_inside_cast.dart.intertwined.expect
index 872a669..5d9a16a 100644
--- a/pkg/front_end/parser_testcases/patterns/null_literal_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_literal_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralNull(case)
                               listener: handleLiteralNull(null)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_literal_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_literal_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_literal_inside_if_case.dart.intertwined.expect
index 326c336..11fbbcb 100644
--- a/pkg/front_end/parser_testcases/patterns/null_literal_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_literal_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralNull(case)
                                 listener: handleLiteralNull(null)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_literal_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_assert.dart.intertwined.expect
index 3c80ee6..3044621 100644
--- a/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralNull(case)
                               listener: handleLiteralNull(null)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/null_literal_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_check.dart.intertwined.expect
index dc91ecd..74ab035 100644
--- a/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/null_literal_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralNull(case)
                               listener: handleLiteralNull(null)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/object_prefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/object_prefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/object_prefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect
index a05efc1..7ebf765 100644
--- a/pkg/front_end/parser_testcases/patterns/object_prefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/object_prefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect
@@ -54,9 +54,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideAssignment.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideAssignment.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideAssignment.dart.intertwined.expect
index e84eae5..a6475f9 100644
--- a/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideAssignment.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideAssignment.dart.intertwined.expect
@@ -61,9 +61,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect
index 9a0854c8..049e4bc 100644
--- a/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/object_prefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withTypeArgs_insideDeclaration.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withTypeArgs_insideDeclaration.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withTypeArgs_insideDeclaration.dart.intertwined.expect
index 8e56a96..40efa7d 100644
--- a/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withTypeArgs_insideDeclaration.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withTypeArgs_insideDeclaration.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect
index 5be4c38..00d8e2b 100644
--- a/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/object_unprefixedNamedUnderscore_withoutTypeArgs_insideDeclaration.dart.intertwined.expect
@@ -54,9 +54,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/object_unprefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/object_unprefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/object_unprefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect
index 5ae6134..5a82825 100644
--- a/pkg/front_end/parser_testcases/patterns/object_unprefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/object_unprefixed_withTypeArgs_insideDeclaration.dart.intertwined.expect
@@ -93,9 +93,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/parenthesized_insideAssignment.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/parenthesized_insideAssignment.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/parenthesized_insideAssignment.dart.intertwined.expect
index ecba959..df1cff4 100644
--- a/pkg/front_end/parser_testcases/patterns/parenthesized_insideAssignment.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/parenthesized_insideAssignment.dart.intertwined.expect
@@ -61,9 +61,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/parenthesized_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/parenthesized_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/parenthesized_insideCase.dart.intertwined.expect
index 85f010b..487663e 100644
--- a/pkg/front_end/parser_testcases/patterns/parenthesized_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/parenthesized_insideCase.dart.intertwined.expect
@@ -47,9 +47,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -73,9 +73,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/parenthesized_insideDeclaration.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/parenthesized_insideDeclaration.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/parenthesized_insideDeclaration.dart.intertwined.expect
index a95645f..70de645 100644
--- a/pkg/front_end/parser_testcases/patterns/parenthesized_insideDeclaration.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/parenthesized_insideDeclaration.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_cast.dart.intertwined.expect
index c98e49a..f7a7540 100644
--- a/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_assert.dart.intertwined.expect
index dc17ac9..1347515 100644
--- a/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_check.dart.intertwined.expect
index ee11ebe..a7cf3f6 100644
--- a/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/parenthesized_pattern_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_disallowsLate.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_disallowsLate.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_disallowsLate.dart.intertwined.expect
index 7e71b93..fff5a29 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_disallowsLate.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_disallowsLate.dart.intertwined.expect
@@ -72,9 +72,9 @@
                     looksLikeOuterPatternEquals(;)
                       skipOuterPattern(;)
                         skipObjectPatternRest(_)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
                               isNextIdentifier(;)
@@ -99,9 +99,9 @@
                     parseExpression(;)
                       looksLikeOuterPatternEquals(;)
                         skipOuterPattern(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
                             parseSend(;, expression)
                               isNextIdentifier(;)
                               ensureIdentifier(;, expression)
@@ -130,9 +130,9 @@
                     parseExpression())
                       looksLikeOuterPatternEquals())
                         skipOuterPattern())
-                      parsePrecedenceExpression(), 1, true)
-                        parseUnaryExpression(), true)
-                          parsePrimary(), expression)
+                      parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(), true, ConstantPatternContext.none)
+                          parsePrimary(), expression, ConstantPatternContext.none)
                             parseSend(), expression)
                               isNextIdentifier())
                               ensureIdentifier(), expression)
@@ -144,9 +144,9 @@
                               parseArgumentsOpt()
                                 listener: handleNoArguments(=)
                               listener: handleSend(, =)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_final_extractor.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_final_extractor.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_final_extractor.dart.intertwined.expect
index f73b7b0..b95bec7 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_final_extractor.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_final_extractor.dart.intertwined.expect
@@ -63,9 +63,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_extractor.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_extractor.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_extractor.dart.intertwined.expect
index aadc9546..2bb5406 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_extractor.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_extractor.dart.intertwined.expect
@@ -63,9 +63,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_list.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_list.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_list.dart.intertwined.expect
index b11d0be..88d6d5c 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_list.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_list.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_map.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_map.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_map.dart.intertwined.expect
index 584da9d..bfb22f4 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_map.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_map.dart.intertwined.expect
@@ -51,9 +51,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
@@ -69,9 +69,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_parenthesized.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_parenthesized.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_parenthesized.dart.intertwined.expect
index a95645f..70de645 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_parenthesized.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_parenthesized.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_record.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_record.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_record.dart.intertwined.expect
index 5bf0080..8a3379d 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_record.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_noMetadata_var_record.dart.intertwined.expect
@@ -59,9 +59,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_extractor.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_extractor.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_extractor.dart.intertwined.expect
index e3007e4..b6978d7 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_extractor.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_extractor.dart.intertwined.expect
@@ -74,9 +74,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_list.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_list.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_list.dart.intertwined.expect
index ea9516d..72d05bf 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_list.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_list.dart.intertwined.expect
@@ -69,9 +69,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_map.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_map.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_map.dart.intertwined.expect
index e1851a0..a0ee3f2 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_map.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_map.dart.intertwined.expect
@@ -62,9 +62,9 @@
                           parseExpression({)
                             looksLikeOuterPatternEquals({)
                               skipOuterPattern({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseLiteralString({)
                                     parseSingleLiteralString({)
                                       listener: beginLiteralString('a')
@@ -80,9 +80,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_parenthesized.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_parenthesized.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_parenthesized.dart.intertwined.expect
index a535dfb..1f442fd 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_parenthesized.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_parenthesized.dart.intertwined.expect
@@ -69,9 +69,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_record.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_record.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_record.dart.intertwined.expect
index 5397146..da1ee45 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_record.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_final_record.dart.intertwined.expect
@@ -70,9 +70,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_extractor.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_extractor.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_extractor.dart.intertwined.expect
index 87dd76a..ffd4900 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_extractor.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_extractor.dart.intertwined.expect
@@ -74,9 +74,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_list.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_list.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_list.dart.intertwined.expect
index b0f3ee8..60fe9fc 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_list.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_list.dart.intertwined.expect
@@ -69,9 +69,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_map.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_map.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_map.dart.intertwined.expect
index 9c293a2..dacdeb9 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_map.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_map.dart.intertwined.expect
@@ -62,9 +62,9 @@
                           parseExpression({)
                             looksLikeOuterPatternEquals({)
                               skipOuterPattern({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseLiteralString({)
                                     parseSingleLiteralString({)
                                       listener: beginLiteralString('a')
@@ -80,9 +80,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_parenthesized.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_parenthesized.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_parenthesized.dart.intertwined.expect
index dbb07b0..eb56c67 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_parenthesized.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_parenthesized.dart.intertwined.expect
@@ -69,9 +69,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_record.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_record.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_record.dart.intertwined.expect
index fa2753b..4afecd5 100644
--- a/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_record.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/patternVariableDeclarationStatement_withMetadata_var_record.dart.intertwined.expect
@@ -70,9 +70,9 @@
                       looksLikeOuterPatternEquals(=)
                         skipOuterPattern(=)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(=, 1, true)
-                        parseUnaryExpression(=, true)
-                          parsePrimary(=, expression)
+                      parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=, true, ConstantPatternContext.none)
+                          parsePrimary(=, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
                                 isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/pattern_inForIn_element.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element.dart.intertwined.expect
index e469acf..3efcb6e 100644
--- a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element.dart.intertwined.expect
@@ -38,9 +38,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     listener: handleNoTypeArguments([)
                     parseLiteralListSuffix(=>, null)
                       listener: beginForControlFlow(null, for)
@@ -73,9 +73,9 @@
                           looksLikeOuterPatternEquals(in)
                             skipOuterPattern(in)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(in, 1, true)
-                            parseUnaryExpression(in, true)
-                              parsePrimary(in, expression)
+                          parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(in, true, ConstantPatternContext.none)
+                              parsePrimary(in, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(in, expression)
                                   parseSend(in, expression)
                                     isNextIdentifier(in)
@@ -91,9 +91,9 @@
                       parseExpression())
                         looksLikeOuterPatternEquals())
                           skipOuterPattern())
-                        parsePrecedenceExpression(), 1, true)
-                          parseUnaryExpression(), true)
-                            parsePrimary(), expression)
+                        parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(), true, ConstantPatternContext.none)
+                            parsePrimary(), expression, ConstantPatternContext.none)
                               parseLiteralInt())
                                 listener: handleLiteralInt(0)
                       listener: endForInControlFlow(0)

pkg/front_end/parser_testcases/patterns/pattern_inForIn_element_withMetadata.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element_withMetadata.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element_withMetadata.dart.intertwined.expect
index 0b12329..aee4ee3 100644
--- a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element_withMetadata.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_element_withMetadata.dart.intertwined.expect
@@ -38,9 +38,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     listener: handleNoTypeArguments([)
                     parseLiteralListSuffix(=>, null)
                       listener: beginForControlFlow(null, for)
@@ -83,9 +83,9 @@
                           looksLikeOuterPatternEquals(in)
                             skipOuterPattern(in)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(in, 1, true)
-                            parseUnaryExpression(in, true)
-                              parsePrimary(in, expression)
+                          parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(in, true, ConstantPatternContext.none)
+                              parsePrimary(in, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(in, expression)
                                   parseSend(in, expression)
                                     isNextIdentifier(in)
@@ -101,9 +101,9 @@
                       parseExpression())
                         looksLikeOuterPatternEquals())
                           skipOuterPattern())
-                        parsePrecedenceExpression(), 1, true)
-                          parseUnaryExpression(), true)
-                            parsePrimary(), expression)
+                        parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(), true, ConstantPatternContext.none)
+                            parsePrimary(), expression, ConstantPatternContext.none)
                               parseLiteralInt())
                                 listener: handleLiteralInt(0)
                       listener: endForInControlFlow(0)

pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement.dart.intertwined.expect
index 120e29a..2832a9c 100644
--- a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement.dart.intertwined.expect
@@ -70,9 +70,9 @@
                       looksLikeOuterPatternEquals(in)
                         skipOuterPattern(in)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(in, 1, true)
-                        parseUnaryExpression(in, true)
-                          parsePrimary(in, expression)
+                      parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(in, true, ConstantPatternContext.none)
+                          parsePrimary(in, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(in, expression)
                               parseSend(in, expression)
                                 isNextIdentifier(in)

pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement_withMetadata.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement_withMetadata.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement_withMetadata.dart.intertwined.expect
index b5d3625..57e07f5 100644
--- a/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement_withMetadata.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/pattern_inForIn_statement_withMetadata.dart.intertwined.expect
@@ -80,9 +80,9 @@
                       looksLikeOuterPatternEquals(in)
                         skipOuterPattern(in)
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression(in, 1, true)
-                        parseUnaryExpression(in, true)
-                          parsePrimary(in, expression)
+                      parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(in, true, ConstantPatternContext.none)
+                          parsePrimary(in, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral(in, expression)
                               parseSend(in, expression)
                                 isNextIdentifier(in)

pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_element.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_element.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_element.dart.intertwined.expect
index d4b0d3a..f91ac8c 100644
--- a/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_element.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_element.dart.intertwined.expect
@@ -38,9 +38,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     listener: handleNoTypeArguments([)
                     parseLiteralListSuffix(=>, null)
                       listener: beginForControlFlow(null, for)
@@ -71,9 +71,9 @@
                         looksLikeOuterPatternEquals(=)
                           skipOuterPattern(=)
                             skipObjectPatternRest(x)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -92,9 +92,9 @@
                       parseExpression())
                         looksLikeOuterPatternEquals())
                           skipOuterPattern())
-                        parsePrecedenceExpression(), 1, true)
-                          parseUnaryExpression(), true)
-                            parsePrimary(), expression)
+                        parsePrecedenceExpression(), 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(), true, ConstantPatternContext.none)
+                            parsePrimary(), expression, ConstantPatternContext.none)
                               parseLiteralInt())
                                 listener: handleLiteralInt(0)
                       listener: endForControlFlow(0)

pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_statement.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_statement.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_statement.dart.intertwined.expect
index 8d6ad05..6b38107 100644
--- a/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_statement.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/pattern_inForInitializer_statement.dart.intertwined.expect
@@ -67,9 +67,9 @@
                   looksLikeOuterPatternEquals(=)
                     skipOuterPattern(=)
                       skipObjectPatternRest(x)
-                  parsePrecedenceExpression(=, 1, true)
-                    parseUnaryExpression(=, true)
-                      parsePrimary(=, expression)
+                  parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(=, true, ConstantPatternContext.none)
+                      parsePrimary(=, expression, ConstantPatternContext.none)
                         parseSendOrFunctionLiteral(=, expression)
                           parseSend(=, expression)
                             isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.intertwined.expect
index f5ab2bf..3eba406 100644
--- a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args.dart.intertwined.expect
@@ -74,9 +74,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.intertwined.expect
index 1cc3b9a..84400e8 100644
--- a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_cast.dart.intertwined.expect
@@ -74,9 +74,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect
index 6c87e77..d1b734a 100644
--- a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_assert.dart.intertwined.expect
@@ -74,9 +74,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.intertwined.expect
index 5c60ee6..f7096dd 100644
--- a/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/prefixed_extractor_pattern_with_type_args_inside_null_check.dart.intertwined.expect
@@ -74,9 +74,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/record_insideAssignment_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_insideAssignment_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_insideAssignment_empty.dart.intertwined.expect
index 7d5d679..01f460c 100644
--- a/pkg/front_end/parser_testcases/patterns/record_insideAssignment_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_insideAssignment_empty.dart.intertwined.expect
@@ -53,9 +53,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/record_insideAssignment_oneField.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_insideAssignment_oneField.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_insideAssignment_oneField.dart.intertwined.expect
index 203d542..d816ac2d 100644
--- a/pkg/front_end/parser_testcases/patterns/record_insideAssignment_oneField.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_insideAssignment_oneField.dart.intertwined.expect
@@ -61,9 +61,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/record_insideAssignment_twoFields.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_insideAssignment_twoFields.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_insideAssignment_twoFields.dart.intertwined.expect
index 2a87ab4..fe6e9dc 100644
--- a/pkg/front_end/parser_testcases/patterns/record_insideAssignment_twoFields.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_insideAssignment_twoFields.dart.intertwined.expect
@@ -67,9 +67,9 @@
                           looksLikeOuterPatternEquals(=)
                             skipOuterPattern(=)
                               skipObjectPatternRest(x)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
                                     isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/record_insideDeclaration_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_empty.dart.intertwined.expect
index a3ce115..3f6a564 100644
--- a/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_empty.dart.intertwined.expect
@@ -50,9 +50,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/record_insideDeclaration_oneField.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_oneField.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_oneField.dart.intertwined.expect
index e92604b..6af4452 100644
--- a/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_oneField.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_oneField.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/record_insideDeclaration_twoFields.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_twoFields.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_twoFields.dart.intertwined.expect
index 0e8675c..e044f6d 100644
--- a/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_twoFields.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_insideDeclaration_twoFields.dart.intertwined.expect
@@ -64,9 +64,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/record_pattern_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case.dart.intertwined.expect
index 4a243b6..dcdba9c 100644
--- a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -85,9 +85,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_empty.dart.intertwined.expect
index 2814583..f0c4c04 100644
--- a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_empty.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_singleton.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_singleton.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_singleton.dart.intertwined.expect
index 81c7249..3d92caa 100644
--- a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_singleton.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_case_singleton.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/record_pattern_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_cast.dart.intertwined.expect
index a7c9a2e..464578a 100644
--- a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -85,9 +85,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_assert.dart.intertwined.expect
index d164a4e..bda6e92 100644
--- a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -85,9 +85,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_check.dart.intertwined.expect
index 3e5ab42..482d5e1 100644
--- a/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/record_pattern_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression((, 17, false)
-                              parseUnaryExpression((, false)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression((, false, ConstantPatternContext.implicit)
+                                parsePrimary((, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(()
                                     listener: handleLiteralInt(1)
                             listener: endConstantPattern(null)
@@ -85,9 +85,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/relational_inside_case_equal.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_case_equal.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_case_equal.dart.intertwined.expect
index b1d8229..5a37adc 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_case_equal.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_case_equal.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(==, 12, false)
-                        parseUnaryExpression(==, false)
-                          parsePrimary(==, expression)
+                      parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(==, false, ConstantPatternContext.none)
+                          parsePrimary(==, expression, ConstantPatternContext.none)
                             parseLiteralInt(==)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(<<)
-                        parsePrecedenceExpression(<<, 13, false)
-                          parseUnaryExpression(<<, false)
-                            parsePrimary(<<, expression)
+                        parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
+                          parseUnaryExpression(<<, false, ConstantPatternContext.none)
+                            parsePrimary(<<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<<)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(<<)

pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than.dart.intertwined.expect
index 1bfaed3..de1f13c 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(>, 12, false)
-                        parseUnaryExpression(>, false)
-                          parsePrimary(>, expression)
+                      parsePrecedenceExpression(>, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(>, false, ConstantPatternContext.none)
+                          parsePrimary(>, expression, ConstantPatternContext.none)
                             parseLiteralInt(>)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(<<)
-                        parsePrecedenceExpression(<<, 13, false)
-                          parseUnaryExpression(<<, false)
-                            parsePrimary(<<, expression)
+                        parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
+                          parseUnaryExpression(<<, false, ConstantPatternContext.none)
+                            parsePrimary(<<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<<)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(<<)

pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than_or_equal.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than_or_equal.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than_or_equal.dart.intertwined.expect
index 6ddd938..b3a0892 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than_or_equal.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_case_greater_than_or_equal.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(>=, 12, false)
-                        parseUnaryExpression(>=, false)
-                          parsePrimary(>=, expression)
+                      parsePrecedenceExpression(>=, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(>=, false, ConstantPatternContext.none)
+                          parsePrimary(>=, expression, ConstantPatternContext.none)
                             parseLiteralInt(>=)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(<<)
-                        parsePrecedenceExpression(<<, 13, false)
-                          parseUnaryExpression(<<, false)
-                            parsePrimary(<<, expression)
+                        parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
+                          parseUnaryExpression(<<, false, ConstantPatternContext.none)
+                            parsePrimary(<<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<<)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(<<)

pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than.dart.intertwined.expect
index ac14f15..35249d2 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(<, 12, false)
-                        parseUnaryExpression(<, false)
-                          parsePrimary(<, expression)
+                      parsePrecedenceExpression(<, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(<, false, ConstantPatternContext.none)
+                          parsePrimary(<, expression, ConstantPatternContext.none)
                             parseLiteralInt(<)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(<<)
-                        parsePrecedenceExpression(<<, 13, false)
-                          parseUnaryExpression(<<, false)
-                            parsePrimary(<<, expression)
+                        parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
+                          parseUnaryExpression(<<, false, ConstantPatternContext.none)
+                            parsePrimary(<<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<<)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(<<)

pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than_or_equal.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than_or_equal.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than_or_equal.dart.intertwined.expect
index 4485e9c..ddabb11 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than_or_equal.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_case_less_than_or_equal.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(<=, 12, false)
-                        parseUnaryExpression(<=, false)
-                          parsePrimary(<=, expression)
+                      parsePrecedenceExpression(<=, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(<=, false, ConstantPatternContext.none)
+                          parsePrimary(<=, expression, ConstantPatternContext.none)
                             parseLiteralInt(<=)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(<<)
-                        parsePrecedenceExpression(<<, 13, false)
-                          parseUnaryExpression(<<, false)
-                            parsePrimary(<<, expression)
+                        parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
+                          parseUnaryExpression(<<, false, ConstantPatternContext.none)
+                            parsePrimary(<<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<<)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(<<)

pkg/front_end/parser_testcases/patterns/relational_inside_case_not_equal.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_case_not_equal.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_case_not_equal.dart.intertwined.expect
index 55d117f..fe0e2de 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_case_not_equal.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_case_not_equal.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,15 +71,15 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(!=, 12, false)
-                        parseUnaryExpression(!=, false)
-                          parsePrimary(!=, expression)
+                      parsePrecedenceExpression(!=, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(!=, false, ConstantPatternContext.none)
+                          parsePrimary(!=, expression, ConstantPatternContext.none)
                             parseLiteralInt(!=)
                               listener: handleLiteralInt(1)
                         listener: beginBinaryExpression(<<)
-                        parsePrecedenceExpression(<<, 13, false)
-                          parseUnaryExpression(<<, false)
-                            parsePrimary(<<, expression)
+                        parsePrecedenceExpression(<<, 13, false, ConstantPatternContext.none)
+                          parseUnaryExpression(<<, false, ConstantPatternContext.none)
+                            parsePrimary(<<, expression, ConstantPatternContext.none)
                               parseLiteralInt(<<)
                                 listener: handleLiteralInt(1)
                         listener: endBinaryExpression(<<)

pkg/front_end/parser_testcases/patterns/relational_inside_extractor_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_extractor_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_extractor_pattern.dart.intertwined.expect
index e54963d..d1882db 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_extractor_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_extractor_pattern.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -121,9 +121,9 @@
                           listener: handleIdentifier(f, namedArgumentReference)
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralInt(==)
                                     listener: handleLiteralInt(1)
                             listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_if_case.dart.intertwined.expect
index b390bac..b78a6ba 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -63,9 +63,9 @@
                                 listener: handleSend(x, case)
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
-                        parsePrecedenceExpression(==, 12, false)
-                          parseUnaryExpression(==, false)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                          parseUnaryExpression(==, false, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(1)
                         listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_list_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_list_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_list_pattern.dart.intertwined.expect
index 7418be4..6a7a4f0 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_list_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_list_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern([, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern([, PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralInt(==)
                                     listener: handleLiteralInt(1)
                             listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_lhs.dart.intertwined.expect
index 304d8c9..5be7585 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,9 +71,9 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(==, 12, false)
-                        parseUnaryExpression(==, false)
-                          parsePrimary(==, expression)
+                      parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(==, false, ConstantPatternContext.none)
+                          parsePrimary(==, expression, ConstantPatternContext.none)
                             parseLiteralInt(==)
                               listener: handleLiteralInt(1)
                       listener: handleRelationalPattern(==)
@@ -81,9 +81,9 @@
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(&&, 17, false)
-                          parseUnaryExpression(&&, false)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
+                            parsePrimary(&&, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(&&)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_rhs.dart.intertwined.expect
index 70e800e..f650598 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_and_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,18 +72,18 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
                     listener: beginBinaryPattern(&&)
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
-                        parsePrecedenceExpression(==, 12, false)
-                          parseUnaryExpression(==, false)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                          parseUnaryExpression(==, false, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(2)
                         listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_lhs.dart.intertwined.expect
index 932598e..4700773 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -71,9 +71,9 @@
                   listener: beginCaseExpression(case)
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
-                      parsePrecedenceExpression(==, 12, false)
-                        parseUnaryExpression(==, false)
-                          parsePrimary(==, expression)
+                      parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                        parseUnaryExpression(==, false, ConstantPatternContext.none)
+                          parsePrimary(==, expression, ConstantPatternContext.none)
                             parseLiteralInt(==)
                               listener: handleLiteralInt(1)
                       listener: handleRelationalPattern(==)
@@ -81,9 +81,9 @@
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(||, 17, false)
-                          parseUnaryExpression(||, false)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(||, false, ConstantPatternContext.implicit)
+                            parsePrimary(||, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(||)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_rhs.dart.intertwined.expect
index 0b5de2f..07beb0d 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_logical_or_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,18 +72,18 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)
                     listener: beginBinaryPattern(||)
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
-                        parsePrecedenceExpression(==, 12, false)
-                          parseUnaryExpression(==, false)
-                            parsePrimary(==, expression)
+                        parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                          parseUnaryExpression(==, false, ConstantPatternContext.none)
+                            parsePrimary(==, expression, ConstantPatternContext.none)
                               parseLiteralInt(==)
                                 listener: handleLiteralInt(2)
                         listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_map_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_map_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_map_pattern.dart.intertwined.expect
index 387022b..ce3ba76 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_map_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_map_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,18 +76,18 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')
                                     listener: endLiteralString(0, :)
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralInt(==)
                                     listener: handleLiteralInt(1)
                             listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_parenthesized_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_parenthesized_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_parenthesized_pattern.dart.intertwined.expect
index fa05025..d0ddbce 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_parenthesized_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_parenthesized_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -74,9 +74,9 @@
                       parseParenthesizedPatternOrRecordPattern(case, PatternContext.matching)
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralInt(==)
                                     listener: handleLiteralInt(1)
                             listener: handleRelationalPattern(==)

pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_named.dart.intertwined.expect
index 19092cd..1f36785 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                           listener: handleIdentifier(n, namedRecordFieldReference)
                         parsePattern(:, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(:, PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralInt(==)
                                     listener: handleLiteralInt(1)
                             listener: handleRelationalPattern(==)
@@ -86,9 +86,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_unnamed.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_unnamed.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_unnamed.dart.intertwined.expect
index ddd8b32..2c00998 100644
--- a/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_unnamed.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/relational_inside_record_pattern_unnamed.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -74,9 +74,9 @@
                       parseParenthesizedPatternOrRecordPattern(case, PatternContext.matching)
                         parsePattern((, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern((, PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralInt(==)
                                     listener: handleLiteralInt(1)
                             listener: handleRelationalPattern(==)
@@ -84,9 +84,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/rest_subpatternStartingTokens.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/rest_subpatternStartingTokens.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/rest_subpatternStartingTokens.dart.intertwined.expect
index 26323e0..96f5bc7 100644
--- a/pkg/front_end/parser_testcases/patterns/rest_subpatternStartingTokens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/rest_subpatternStartingTokens.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
-                            parsePrecedenceExpression(==, 12, false)
-                              parseUnaryExpression(==, false)
-                                parsePrimary(==, expression)
+                            parsePrecedenceExpression(==, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(==, false, ConstantPatternContext.none)
+                                parsePrimary(==, expression, ConstantPatternContext.none)
                                   parseLiteralNull(==)
                                     listener: handleLiteralNull(null)
                             listener: handleRelationalPattern(==)
@@ -91,9 +91,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
-                            parsePrecedenceExpression(!=, 12, false)
-                              parseUnaryExpression(!=, false)
-                                parsePrimary(!=, expression)
+                            parsePrecedenceExpression(!=, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(!=, false, ConstantPatternContext.none)
+                                parsePrimary(!=, expression, ConstantPatternContext.none)
                                   parseLiteralNull(!=)
                                     listener: handleLiteralNull(null)
                             listener: handleRelationalPattern(!=)
@@ -110,9 +110,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
-                            parsePrecedenceExpression(<, 12, false)
-                              parseUnaryExpression(<, false)
-                                parsePrimary(<, expression)
+                            parsePrecedenceExpression(<, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(<, false, ConstantPatternContext.none)
+                                parsePrimary(<, expression, ConstantPatternContext.none)
                                   parseLiteralInt(<)
                                     listener: handleLiteralInt(0)
                             listener: handleRelationalPattern(<)
@@ -129,9 +129,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
-                            parsePrecedenceExpression(>, 12, false)
-                              parseUnaryExpression(>, false)
-                                parsePrimary(>, expression)
+                            parsePrecedenceExpression(>, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(>, false, ConstantPatternContext.none)
+                                parsePrimary(>, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>)
                                     listener: handleLiteralInt(0)
                             listener: handleRelationalPattern(>)
@@ -148,9 +148,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
-                            parsePrecedenceExpression(<=, 12, false)
-                              parseUnaryExpression(<=, false)
-                                parsePrimary(<=, expression)
+                            parsePrecedenceExpression(<=, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(<=, false, ConstantPatternContext.none)
+                                parsePrimary(<=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(<=)
                                     listener: handleLiteralInt(0)
                             listener: handleRelationalPattern(<=)
@@ -167,9 +167,9 @@
                       parseListPatternSuffix(case, PatternContext.matching)
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
-                            parsePrecedenceExpression(>=, 12, false)
-                              parseUnaryExpression(>=, false)
-                                parsePrimary(>=, expression)
+                            parsePrecedenceExpression(>=, 12, false, ConstantPatternContext.none)
+                              parseUnaryExpression(>=, false, ConstantPatternContext.none)
+                                parsePrimary(>=, expression, ConstantPatternContext.none)
                                   parseLiteralInt(>=)
                                     listener: handleLiteralInt(0)
                             listener: handleRelationalPattern(>=)
@@ -187,9 +187,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(...)
                                     listener: handleLiteralInt(0)
                             listener: endConstantPattern(null)
@@ -207,9 +207,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralDouble(...)
                                     listener: handleLiteralDouble(0.0)
                             listener: endConstantPattern(null)
@@ -227,9 +227,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(...)
                                     listener: handleLiteralInt(0x0)
                             listener: endConstantPattern(null)
@@ -247,9 +247,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralNull(...)
                                     listener: handleLiteralNull(null)
                             listener: endConstantPattern(null)
@@ -267,9 +267,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralBool(...)
                                     listener: handleLiteralBool(false)
                             listener: endConstantPattern(null)
@@ -287,9 +287,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralBool(...)
                                     listener: handleLiteralBool(true)
                             listener: endConstantPattern(null)
@@ -307,9 +307,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseLiteralString(...)
                                     parseSingleLiteralString(...)
                                       listener: beginLiteralString('foo')
@@ -329,9 +329,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(..., 17, false)
-                              parseUnaryExpression(..., false)
-                                parsePrimary(..., expression)
+                            parsePrecedenceExpression(..., 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(..., false, ConstantPatternContext.implicit)
+                                parsePrimary(..., expression, ConstantPatternContext.implicit)
                                   parseSendOrFunctionLiteral(..., expression)
                                     parseSend(..., expression)
                                       isNextIdentifier(...)
@@ -356,9 +356,9 @@
                         parsePattern(..., PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(..., PatternContext.matching)
                             listener: beginConstantPattern(const)
-                            parsePrecedenceExpression(const, 17, false)
-                              parseUnaryExpression(const, false)
-                                parsePrimary(const, expression)
+                            parsePrecedenceExpression(const, 17, false, ConstantPatternContext.explicit)
+                              parseUnaryExpression(const, false, ConstantPatternContext.explicit)
+                                parsePrimary(const, expression, ConstantPatternContext.explicit)
                                   parseSendOrFunctionLiteral(const, expression)
                                     looksLikeFunctionBody(])
                                     parseSend(const, expression)

pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideList.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideList.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideList.dart.intertwined.expect
index 13694cb..54cec04 100644
--- a/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideList.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideList.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideMap.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideMap.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideMap.dart.intertwined.expect
index 27d11a7..85074a3 100644
--- a/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideMap.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/rest_withSubpattern_insideMap.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideList.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideList.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideList.dart.intertwined.expect
index 397727d..a9266fe 100644
--- a/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideList.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideList.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideMap.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideMap.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideMap.dart.intertwined.expect
index af776de..7f5b821 100644
--- a/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideMap.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/rest_withoutSubpattern_insideMap.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/skipOuterPattern_eof.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/skipOuterPattern_eof.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/skipOuterPattern_eof.dart.intertwined.expect
index 5cead0b..45420f8 100644
--- a/pkg/front_end/parser_testcases/patterns/skipOuterPattern_eof.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/skipOuterPattern_eof.dart.intertwined.expect
@@ -36,9 +36,9 @@
                     looksLikeOuterPatternEquals({)
                       skipOuterPattern({)
                         skipObjectPatternRest(int)
-                    parsePrecedenceExpression({, 1, true)
-                      parseUnaryExpression({, true)
-                        parsePrimary({, expression)
+                    parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression({, true, ConstantPatternContext.none)
+                        parsePrimary({, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
                               isNextIdentifier({)
@@ -77,9 +77,9 @@
                       parseExpression(=)
                         looksLikeOuterPatternEquals(=)
                           skipOuterPattern(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralInt(=)
                                 listener: handleLiteralInt(0)
                       listener: endVariableInitializer(=)

pkg/front_end/parser_testcases/patterns/string_literal_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/string_literal_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/string_literal_inside_case.dart.intertwined.expect
index 988a8e8..b6f478f 100644
--- a/pkg/front_end/parser_testcases/patterns/string_literal_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/string_literal_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralString(case)
                               parseSingleLiteralString(case)
                                 listener: beginLiteralString("x")

pkg/front_end/parser_testcases/patterns/string_literal_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/string_literal_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/string_literal_inside_cast.dart.intertwined.expect
index 73d1c23..9f9b3e6 100644
--- a/pkg/front_end/parser_testcases/patterns/string_literal_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/string_literal_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralString(case)
                               parseSingleLiteralString(case)
                                 listener: beginLiteralString("x")

pkg/front_end/parser_testcases/patterns/string_literal_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/string_literal_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/string_literal_inside_if_case.dart.intertwined.expect
index 0931c26..58c950a 100644
--- a/pkg/front_end/parser_testcases/patterns/string_literal_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/string_literal_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -64,9 +64,9 @@
                     parsePattern(case, PatternContext.matching, precedence: 1)
                       parsePrimaryPattern(case, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(case, 17, false)
-                          parseUnaryExpression(case, false)
-                            parsePrimary(case, expression)
+                        parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                            parsePrimary(case, expression, ConstantPatternContext.implicit)
                               parseLiteralString(case)
                                 parseSingleLiteralString(case)
                                   listener: beginLiteralString("x")

pkg/front_end/parser_testcases/patterns/string_literal_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_assert.dart.intertwined.expect
index c6134bf..cadc363 100644
--- a/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralString(case)
                               parseSingleLiteralString(case)
                                 listener: beginLiteralString("x")

pkg/front_end/parser_testcases/patterns/string_literal_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_check.dart.intertwined.expect
index 0103333..9f09ceb 100644
--- a/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/string_literal_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralString(case)
                               parseSingleLiteralString(case)
                                 listener: beginLiteralString("x")

pkg/front_end/parser_testcases/patterns/switchExpression_empty.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/switchExpression_empty.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/switchExpression_empty.dart.intertwined.expect
index c7a0494..7600433 100644
--- a/pkg/front_end/parser_testcases/patterns/switchExpression_empty.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/switchExpression_empty.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_guarded.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_guarded.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_guarded.dart.intertwined.expect
index f96531e..39f3b3b 100644
--- a/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_guarded.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_guarded.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -77,18 +77,18 @@
                       parseExpression(when)
                         looksLikeOuterPatternEquals(when)
                           skipOuterPattern(when)
-                        parsePrecedenceExpression(when, 1, true)
-                          parseUnaryExpression(when, true)
-                            parsePrimary(when, expression)
+                        parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(when, true, ConstantPatternContext.none)
+                            parsePrimary(when, expression, ConstantPatternContext.none)
                               parseLiteralBool(when)
                                 listener: handleLiteralBool(true)
                       ensureFunctionArrow(true)
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(when, =>, 0)

pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.intertwined.expect
index debd1e6..a114735 100644
--- a/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_noTrailingComma.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -78,9 +78,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_trailingComma.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_trailingComma.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_trailingComma.dart.intertwined.expect
index debd1e6..a114735 100644
--- a/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_trailingComma.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/switchExpression_onePattern_trailingComma.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -78,9 +78,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)

pkg/front_end/parser_testcases/patterns/switchExpression_twoPatterns.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/switchExpression_twoPatterns.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/switchExpression_twoPatterns.dart.intertwined.expect
index cc880bd..fbd93ae 100644
--- a/pkg/front_end/parser_testcases/patterns/switchExpression_twoPatterns.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/switchExpression_twoPatterns.dart.intertwined.expect
@@ -39,9 +39,9 @@
             parseExpression(=>)
               looksLikeOuterPatternEquals(=>)
                 skipOuterPattern(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
                     inPlainSync()
                     parseSwitchExpression(=>)
                       listener: beginSwitchExpression(switch)
@@ -51,9 +51,9 @@
                             looksLikeOuterPatternEquals(()
                               skipOuterPattern(()
                                 skipObjectPatternRest(x)
-                            parsePrecedenceExpression((, 1, true)
-                              parseUnaryExpression((, true)
-                                parsePrimary((, expression)
+                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                parsePrimary((, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
                                       isNextIdentifier(()
@@ -80,9 +80,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(0)
                       listener: endSwitchExpressionCase(null, =>, 0)
@@ -97,9 +97,9 @@
                       parseExpression(=>)
                         looksLikeOuterPatternEquals(=>)
                           skipOuterPattern(=>)
-                        parsePrecedenceExpression(=>, 1, true)
-                          parseUnaryExpression(=>, true)
-                            parsePrimary(=>, expression)
+                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                            parsePrimary(=>, expression, ConstantPatternContext.none)
                               parseLiteralInt(=>)
                                 listener: handleLiteralInt(1)
                       listener: endSwitchExpressionCase(null, =>, 1)

pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_case.dart.intertwined.expect
index 50a5052..d1d087a 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_cast.dart.intertwined.expect
index f5c0e65..5ebc1e8 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_if_case.dart.intertwined.expect
index 1a74858..13036fe 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_assert.dart.intertwined.expect
index a96f275..641d22a 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_check.dart.intertwined.expect
index 04174d1..4fd8abb 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_final_variable_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_case.dart.intertwined.expect
index 67973e9..736bcaf 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_cast.dart.intertwined.expect
index 7b0f688..d7545af 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_if_case.dart.intertwined.expect
index eefd064..06e6727 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_assert.dart.intertwined.expect
index ee73b5a..4ae4783 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_check.dart.intertwined.expect
index cb92eef..36d8d70 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_case.dart.intertwined.expect
index 3d0c5c2..186a983 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_cast.dart.intertwined.expect
index c8da733..dfd62c5 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.intertwined.expect
index ec7a233..e1b46e6 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
index 4b394c1..5c1b480 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_extractor_pattern_implicitly_named.dart.intertwined.expect
@@ -93,9 +93,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_if_case.dart.intertwined.expect
index 2671e52..9bc5810 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.intertwined.expect
index a10a165..60894f9 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_list_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.intertwined.expect
index f6f2c33..7cad186 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -80,9 +80,9 @@
                     parsePattern(&&, PatternContext.matching, precedence: 7)
                       parsePrimaryPattern(&&, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(&&, 17, false)
-                          parseUnaryExpression(&&, false)
-                            parsePrimary(&&, expression)
+                        parsePrecedenceExpression(&&, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(&&, false, ConstantPatternContext.implicit)
+                            parsePrimary(&&, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(&&)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.intertwined.expect
index 2913826..eb96f0f 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_and_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.intertwined.expect
index 4695442..81b5565 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_lhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -80,9 +80,9 @@
                     parsePattern(||, PatternContext.matching, precedence: 6)
                       parsePrimaryPattern(||, PatternContext.matching)
                         listener: beginConstantPattern(null)
-                        parsePrecedenceExpression(||, 17, false)
-                          parseUnaryExpression(||, false)
-                            parsePrimary(||, expression)
+                        parsePrecedenceExpression(||, 17, false, ConstantPatternContext.implicit)
+                          parseUnaryExpression(||, false, ConstantPatternContext.implicit)
+                            parsePrimary(||, expression, ConstantPatternContext.implicit)
                               parseLiteralInt(||)
                                 listener: handleLiteralInt(2)
                         listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.intertwined.expect
index 30a267a..1918f98 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_logical_or_rhs.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -72,9 +72,9 @@
                   parsePattern(case, PatternContext.matching, precedence: 1)
                     parsePrimaryPattern(case, PatternContext.matching)
                       listener: beginConstantPattern(null)
-                      parsePrecedenceExpression(case, 17, false)
-                        parseUnaryExpression(case, false)
-                          parsePrimary(case, expression)
+                      parsePrecedenceExpression(case, 17, false, ConstantPatternContext.implicit)
+                        parseUnaryExpression(case, false, ConstantPatternContext.implicit)
+                          parsePrimary(case, expression, ConstantPatternContext.implicit)
                             parseLiteralInt(case)
                               listener: handleLiteralInt(1)
                       listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.intertwined.expect
index 6fa02e8..6b7422d 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_map_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -76,9 +76,9 @@
                         parseExpression({)
                           looksLikeOuterPatternEquals({)
                             skipOuterPattern({)
-                          parsePrecedenceExpression({, 1, true)
-                            parseUnaryExpression({, true)
-                              parsePrimary({, expression)
+                          parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression({, true, ConstantPatternContext.none)
+                              parsePrimary({, expression, ConstantPatternContext.none)
                                 parseLiteralString({)
                                   parseSingleLiteralString({)
                                     listener: beginLiteralString('a')

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_assert.dart.intertwined.expect
index 04a2822..d8437a5 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_check.dart.intertwined.expect
index 0a839c9..92b9baa 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.intertwined.expect
index a032640..a39a1a2 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_parenthesized_pattern.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.intertwined.expect
index e7a176e..1da085c 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_implicitly_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -84,9 +84,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.intertwined.expect
index 41eda1b..3d49318 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_named.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -85,9 +85,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.intertwined.expect
index 1121a4d..00c2639 100644
--- a/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/typed_variable_named_as_inside_record_pattern_unnamed.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -83,9 +83,9 @@
                         parsePattern(,, PatternContext.matching, precedence: 1)
                           parsePrimaryPattern(,, PatternContext.matching)
                             listener: beginConstantPattern(null)
-                            parsePrecedenceExpression(,, 17, false)
-                              parseUnaryExpression(,, false)
-                                parsePrimary(,, expression)
+                            parsePrecedenceExpression(,, 17, false, ConstantPatternContext.implicit)
+                              parseUnaryExpression(,, false, ConstantPatternContext.implicit)
+                                parsePrimary(,, expression, ConstantPatternContext.implicit)
                                   parseLiteralInt(,)
                                     listener: handleLiteralInt(2)
                             listener: endConstantPattern(null)

pkg/front_end/parser_testcases/patterns/var_variable_inside_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/var_variable_inside_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/var_variable_inside_case.dart.intertwined.expect
index ca05ccb..7605dc3 100644
--- a/pkg/front_end/parser_testcases/patterns/var_variable_inside_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/var_variable_inside_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/var_variable_inside_cast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/var_variable_inside_cast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/var_variable_inside_cast.dart.intertwined.expect
index f9914f4..39c33ad 100644
--- a/pkg/front_end/parser_testcases/patterns/var_variable_inside_cast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/var_variable_inside_cast.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/var_variable_inside_if_case.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/var_variable_inside_if_case.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/var_variable_inside_if_case.dart.intertwined.expect
index 19a111f..9d9e554 100644
--- a/pkg/front_end/parser_testcases/patterns/var_variable_inside_if_case.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/var_variable_inside_if_case.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/var_variable_inside_null_assert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_assert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_assert.dart.intertwined.expect
index 2c33e9c..b168e2e 100644
--- a/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_assert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_assert.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/var_variable_inside_null_check.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_check.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_check.dart.intertwined.expect
index 96ab7a3..22bb4ae 100644
--- a/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_check.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/var_variable_inside_null_check.dart.intertwined.expect
@@ -49,9 +49,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/variable_bare_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_bare_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_bare_insideCast.dart.intertwined.expect
index 7438844..bf3e8f7 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_bare_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_bare_insideCast.dart.intertwined.expect
@@ -64,9 +64,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/variable_bare_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_bare_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_bare_insideNullAssert.dart.intertwined.expect
index 25e92a9..876eaec 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_bare_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_bare_insideNullAssert.dart.intertwined.expect
@@ -58,9 +58,9 @@
                     looksLikeOuterPatternEquals(=)
                       skipOuterPattern(=)
                         skipObjectPatternRest(x)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
                               isNextIdentifier(=)

pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_absurd.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_absurd.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_absurd.dart.intertwined.expect
index fd4e790..a5cc152 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_absurd.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_absurd.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -85,9 +85,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(as)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
@@ -109,9 +109,9 @@
                         listener: handleAsOperator(as)
                         skipChainedAsIsOperators(when)
                       listener: beginBinaryExpression(==)
-                      parsePrecedenceExpression(==, 8, true)
-                        parseUnaryExpression(==, true)
-                          parsePrimary(==, expression)
+                      parsePrecedenceExpression(==, 8, true, ConstantPatternContext.none)
+                        parseUnaryExpression(==, true, ConstantPatternContext.none)
+                          parsePrimary(==, expression, ConstantPatternContext.none)
                             inPlainSync()
                             parseSendOrFunctionLiteral(==, expression)
                               parseSend(==, expression)

pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_beforeWhen.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_beforeWhen.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_beforeWhen.dart.intertwined.expect
index 9a4c5ce..1f48fa8 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_beforeWhen.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedAs_beforeWhen.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -77,9 +77,9 @@
                   parseExpression(when)
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseLiteralBool(when)
                             listener: handleLiteralBool(true)
                   listener: endSwitchCaseWhenClause(true)

pkg/front_end/parser_testcases/patterns/variable_typedNamedUnderscore_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedUnderscore_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedUnderscore_insideCase.dart.intertwined.expect
index ce03c57..9761ca0 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedUnderscore_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedUnderscore_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_absurd.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_absurd.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_absurd.dart.intertwined.expect
index 14043a4..4810ab3 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_absurd.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_absurd.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -78,9 +78,9 @@
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
                         skipObjectPatternRest(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           inPlainSync()
                           parseSendOrFunctionLiteral(when, expression)
                             parseSend(when, expression)
@@ -93,9 +93,9 @@
                                 listener: handleNoArguments(>)
                               listener: handleSend(when, >)
                       listener: beginBinaryExpression(>)
-                      parsePrecedenceExpression(>, 9, true)
-                        parseUnaryExpression(>, true)
-                          parsePrimary(>, expression)
+                      parsePrecedenceExpression(>, 9, true, ConstantPatternContext.none)
+                        parseUnaryExpression(>, true, ConstantPatternContext.none)
+                          parsePrimary(>, expression, ConstantPatternContext.none)
                             parseLiteralInt(>)
                               listener: handleLiteralInt(0)
                       listener: endBinaryExpression(>)

pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_beforeWhen.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_beforeWhen.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_beforeWhen.dart.intertwined.expect
index cd895ca..3b3cc83 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_beforeWhen.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_beforeWhen.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -77,9 +77,9 @@
                   parseExpression(when)
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseLiteralBool(when)
                             listener: handleLiteralBool(true)
                   listener: endSwitchCaseWhenClause(true)

pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCase.dart.intertwined.expect
index fff70c5..034248c 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCast.dart.intertwined.expect
index 19d99fa..5883205 100644
--- a/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/variable_typedNamedWhen_insideCast.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_bare_beforeWhen.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_bare_beforeWhen.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_bare_beforeWhen.dart.intertwined.expect
index 74497e1..ac46f65 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_bare_beforeWhen.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_bare_beforeWhen.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -75,9 +75,9 @@
                   parseExpression(when)
                     looksLikeOuterPatternEquals(when)
                       skipOuterPattern(when)
-                    parsePrecedenceExpression(when, 1, true)
-                      parseUnaryExpression(when, true)
-                        parsePrimary(when, expression)
+                    parsePrecedenceExpression(when, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(when, true, ConstantPatternContext.none)
+                        parsePrimary(when, expression, ConstantPatternContext.none)
                           parseLiteralBool(when)
                             listener: handleLiteralBool(true)
                   listener: endSwitchCaseWhenClause(true)

pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCase.dart.intertwined.expect
index 8c99cdf..911e3ca 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCast.dart.intertwined.expect
index cd1df89..d6ab689 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideCast.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_bare_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideIfCase.dart.intertwined.expect
index e62a8bc..8a9f4dc 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideIfCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullAssert.dart.intertwined.expect
index 3d2ffbf..5bee939 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullAssert.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullCheck.dart.intertwined.expect
index cc84607..fef022b 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_bare_insideNullCheck.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCase.dart.intertwined.expect
index 70484f3..83e9b0b 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCast.dart.intertwined.expect
index 4251b71..1bb7888 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideCast.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideIfCase.dart.intertwined.expect
index 92bf338..032bbfa 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideIfCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullAssert.dart.intertwined.expect
index e553aec..d5d4e5f 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullAssert.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullCheck.dart.intertwined.expect
index 6f545f1..d97f424 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_typed_insideNullCheck.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCase.dart.intertwined.expect
index f920901..915c1ec 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCast.dart.intertwined.expect
index 01b4e80..362436e 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideCast.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideIfCase.dart.intertwined.expect
index d7fcd80..7c127c7 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideIfCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullAssert.dart.intertwined.expect
index f135e4d..109a9b0 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullAssert.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullCheck.dart.intertwined.expect
index 2469e63..3bd5b86 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_final_untyped_insideNullCheck.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCase.dart.intertwined.expect
index 248b237..1099112 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCast.dart.intertwined.expect
index 44e2324..6d45519 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideCast.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_typed_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideIfCase.dart.intertwined.expect
index c64245a..6db8fd7 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideIfCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullAssert.dart.intertwined.expect
index 1b8bda9..b509b74 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullAssert.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullCheck.dart.intertwined.expect
index 75bcd58..414b26e 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_typed_insideNullCheck.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_var_insideCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCase.dart.intertwined.expect
index 5379cb3..c2dbd5f 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_var_insideCast.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCast.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCast.dart.intertwined.expect
index 38d8843..4dcf912 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCast.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideCast.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_var_insideIfCase.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideIfCase.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideIfCase.dart.intertwined.expect
index 6b0cdf9..a8856bd 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideIfCase.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideIfCase.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullAssert.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullAssert.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullAssert.dart.intertwined.expect
index 9ee36cf..d4592e5 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullAssert.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullAssert.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullCheck.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullCheck.dart.intertwined.expect b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullCheck.dart.intertwined.expect
index c4e025a..e84cc25 100644
--- a/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullCheck.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/patterns/wildcard_var_insideNullCheck.dart.intertwined.expect
@@ -46,9 +46,9 @@
                       looksLikeOuterPatternEquals(()
                         skipOuterPattern(()
                           skipObjectPatternRest(x)
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()

pkg/front_end/parser_testcases/record/is_and_as.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/is_and_as.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/is_and_as.dart.intertwined.expect
index 67eece23..996e374 100644
--- a/pkg/front_end/parser_testcases/record/is_and_as.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/is_and_as.dart.intertwined.expect
@@ -55,9 +55,9 @@
                     parseVariableInitializerOpt(b)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -79,9 +79,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -135,9 +135,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -150,9 +150,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString("a is (int, int)")
@@ -182,9 +182,9 @@
                     parseVariableInitializerOpt(c)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 looksLikeFunctionBody(;)
                                 parseSend(=, expression)

pkg/front_end/parser_testcases/record/is_record_conditional_expression.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/is_record_conditional_expression.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/is_record_conditional_expression.dart.intertwined.expect
index e076856..6248435 100644
--- a/pkg/front_end/parser_testcases/record/is_record_conditional_expression.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/is_record_conditional_expression.dart.intertwined.expect
@@ -55,9 +55,9 @@
                     parseVariableInitializerOpt(b)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
                                   isNextIdentifier(=)
@@ -99,17 +99,17 @@
                           parseConditionalExpressionRest())
                             listener: beginConditionalExpression(?)
                             parseExpressionWithoutCascade(?)
-                              parsePrecedenceExpression(?, 1, false)
-                                parseUnaryExpression(?, false)
-                                  parsePrimary(?, expression)
+                              parsePrecedenceExpression(?, 1, false, ConstantPatternContext.none)
+                                parseUnaryExpression(?, false, ConstantPatternContext.none)
+                                  parsePrimary(?, expression, ConstantPatternContext.none)
                                     parseLiteralInt(?)
                                       listener: handleLiteralInt(42)
                             ensureColon(42)
                             listener: handleConditionalExpressionColon()
                             parseExpressionWithoutCascade(:)
-                              parsePrecedenceExpression(:, 1, false)
-                                parseUnaryExpression(:, false)
-                                  parsePrimary(:, expression)
+                              parsePrecedenceExpression(:, 1, false, ConstantPatternContext.none)
+                                parseUnaryExpression(:, false, ConstantPatternContext.none)
+                                  parsePrimary(:, expression, ConstantPatternContext.none)
                                     parseLiteralInt(:)
                                       listener: handleLiteralInt(43)
                             listener: endConditionalExpression(?, :)

pkg/front_end/parser_testcases/record/metadata.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/metadata.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/metadata.dart.intertwined.expect
index 327b14d..392340d 100644
--- a/pkg/front_end/parser_testcases/record/metadata.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/metadata.dart.intertwined.expect
@@ -16,9 +16,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral((, expression)
                         parseSend((, expression)
                           isNextIdentifier(()
@@ -29,9 +29,9 @@
                             listener: handleNoArguments(,)
                           listener: handleSend(x, ,)
               parseExpression(,)
-                parsePrecedenceExpression(,, 1, true)
-                  parseUnaryExpression(,, true)
-                    parsePrimary(,, expression)
+                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                    parsePrimary(,, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(,, expression)
                         parseSend(,, expression)
                           isNextIdentifier(,)
@@ -76,9 +76,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral((, expression)
                         parseSend((, expression)
                           isNextIdentifier(()
@@ -89,9 +89,9 @@
                             listener: handleNoArguments(,)
                           listener: handleSend(x, ,)
               parseExpression(,)
-                parsePrecedenceExpression(,, 1, true)
-                  parseUnaryExpression(,, true)
-                    parsePrimary(,, expression)
+                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                    parsePrimary(,, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(,, expression)
                         parseSend(,, expression)
                           isNextIdentifier(,)
@@ -136,9 +136,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral((, expression)
                         parseSend((, expression)
                           isNextIdentifier(()
@@ -149,9 +149,9 @@
                             listener: handleNoArguments(,)
                           listener: handleSend(x, ,)
               parseExpression(,)
-                parsePrecedenceExpression(,, 1, true)
-                  parseUnaryExpression(,, true)
-                    parsePrimary(,, expression)
+                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                    parsePrimary(,, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(,, expression)
                         parseSend(,, expression)
                           isNextIdentifier(,)
@@ -368,9 +368,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral((, expression)
                         parseSend((, expression)
                           isNextIdentifier(()
@@ -381,9 +381,9 @@
                             listener: handleNoArguments(,)
                           listener: handleSend(x, ,)
               parseExpression(,)
-                parsePrecedenceExpression(,, 1, true)
-                  parseUnaryExpression(,, true)
-                    parsePrimary(,, expression)
+                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                    parsePrimary(,, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(,, expression)
                         parseSend(,, expression)
                           isNextIdentifier(,)
@@ -439,9 +439,9 @@
             parseArgumentsRest(()
               listener: beginArguments(()
               parseExpression(()
-                parsePrecedenceExpression((, 1, true)
-                  parseUnaryExpression((, true)
-                    parsePrimary((, expression)
+                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                    parsePrimary((, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral((, expression)
                         parseSend((, expression)
                           isNextIdentifier(()
@@ -452,9 +452,9 @@
                             listener: handleNoArguments(,)
                           listener: handleSend(x, ,)
               parseExpression(,)
-                parsePrecedenceExpression(,, 1, true)
-                  parseUnaryExpression(,, true)
-                    parsePrimary(,, expression)
+                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                    parsePrimary(,, expression, ConstantPatternContext.none)
                       parseSendOrFunctionLiteral(,, expression)
                         parseSend(,, expression)
                           isNextIdentifier(,)

pkg/front_end/parser_testcases/record/on.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/on.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/on.dart.intertwined.expect
index 62a2eca..b4d84d1 100644
--- a/pkg/front_end/parser_testcases/record/on.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/on.dart.intertwined.expect
@@ -41,9 +41,9 @@
                         looksLikeLocalFunction(print)
                         parseExpressionStatement({)
                           parseExpression({)
-                            parsePrecedenceExpression({, 1, true)
-                              parseUnaryExpression({, true)
-                                parsePrimary({, expression)
+                            parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression({, true, ConstantPatternContext.none)
+                                parsePrimary({, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
@@ -56,9 +56,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(()
                                                       listener: handleLiteralInt(0)
                                             listener: endArguments(1, (, ))

pkg/front_end/parser_testcases/record/operator_returning_record.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/operator_returning_record.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/operator_returning_record.dart.intertwined.expect
index 494e9c7..ca3125b 100644
--- a/pkg/front_end/parser_testcases/record/operator_returning_record.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/operator_returning_record.dart.intertwined.expect
@@ -91,22 +91,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(42)
                                     ensureCloseParen(42, ()
@@ -211,22 +211,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(42)
                                     ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_and_commas.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_and_commas.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_and_commas.dart.intertwined.expect
index 1fcd398..7b28b3b 100644
--- a/pkg/front_end/parser_testcases/record/record_and_commas.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_and_commas.dart.intertwined.expect
@@ -46,11 +46,11 @@
                       parseVariableInitializerOpt(emptyRecord1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen((, ()
                                     listener: endRecordLiteral((, 0, null)
@@ -80,11 +80,11 @@
                       parseVariableInitializerOpt(emptyRecord2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen((, ()
                                     listener: endRecordLiteral((, 0, null)
@@ -112,11 +112,11 @@
                       parseVariableInitializerOpt(emptyRecord3)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen(,, ()
                                     reportRecoverableError(,, RecordLiteralZeroFieldsWithTrailingComma)
@@ -148,11 +148,11 @@
                       parseVariableInitializerOpt(emptyRecord4)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen(,, ()
                                     reportRecoverableError(,, RecordLiteralZeroFieldsWithTrailingComma)
@@ -205,28 +205,28 @@
                       parseVariableInitializerOpt(emptyRecord5)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSend(,, expression)
                                               isNextIdentifier(,)
                                               ensureIdentifier(,, expression)
@@ -297,28 +297,28 @@
                       parseVariableInitializerOpt(emptyRecord6)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSend(,, expression)
                                               isNextIdentifier(,)
                                               ensureIdentifier(,, expression)
@@ -392,28 +392,28 @@
                       parseVariableInitializerOpt(emptyRecord7)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSend(,, expression)
                                               isNextIdentifier(,)
                                               ensureIdentifier(,, expression)
@@ -426,9 +426,9 @@
                                                 listener: handleNoArguments(,)
                                               listener: handleSend(, ,)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSend(,, expression)
                                               isNextIdentifier(,)
                                               ensureIdentifier(,, expression)
@@ -512,28 +512,28 @@
                       parseVariableInitializerOpt(emptyRecord8)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSend(,, expression)
                                               isNextIdentifier(,)
                                               ensureIdentifier(,, expression)
@@ -546,9 +546,9 @@
                                                 listener: handleNoArguments(,)
                                               listener: handleSend(, ,)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseSend(,, expression)
                                               isNextIdentifier(,)
                                               ensureIdentifier(,, expression)

pkg/front_end/parser_testcases/record/record_literal_01.dart.intertwined.expect

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
index 6c6e596..a0d054a 100644
--- 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
@@ -42,39 +42,39 @@
                     parseVariableInitializerOpt(record1)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(1)
                                   parseExpression(,)
-                                    parsePrecedenceExpression(,, 1, true)
-                                      parseUnaryExpression(,, true)
-                                        parsePrimary(,, expression)
+                                    parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                        parsePrimary(,, expression, ConstantPatternContext.none)
                                           parseLiteralInt(,)
                                             listener: handleLiteralInt(2)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(a, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(3)
                                   listener: handleNamedRecordField(:)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(b, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(4)
                                   listener: handleNamedRecordField(:)
@@ -101,39 +101,39 @@
                     parseVariableInitializerOpt(record2)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(1)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(a, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(2)
                                   listener: handleNamedRecordField(:)
                                   parseExpression(,)
-                                    parsePrecedenceExpression(,, 1, true)
-                                      parseUnaryExpression(,, true)
-                                        parsePrimary(,, expression)
+                                    parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                        parsePrimary(,, expression, ConstantPatternContext.none)
                                           parseLiteralInt(,)
                                             listener: handleLiteralInt(3)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(b, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(4)
                                   listener: handleNamedRecordField(:)
@@ -150,9 +150,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -165,9 +165,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -177,7 +177,7 @@
                                                 parseArgumentsOpt(record2)
                                                   listener: handleNoArguments(.)
                                                 listener: handleSend(record2, .)
-                                        parsePrimary(., expressionContinuation)
+                                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
                                               isNextIdentifier(.)
@@ -199,9 +199,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -214,9 +214,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -226,7 +226,7 @@
                                                 parseArgumentsOpt(record2)
                                                   listener: handleNoArguments(.)
                                                 listener: handleSend(record2, .)
-                                        parsePrimary(., expressionContinuation)
+                                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
                                               isNextIdentifier(.)
@@ -248,9 +248,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -263,9 +263,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -275,7 +275,7 @@
                                                 parseArgumentsOpt(record2)
                                                   listener: handleNoArguments(.)
                                                 listener: handleSend(record2, .)
-                                        parsePrimary(., expressionContinuation)
+                                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
                                               isNextIdentifier(.)
@@ -297,9 +297,9 @@
                 looksLikeLocalFunction(print)
                 parseExpressionStatement(;)
                   parseExpression(;)
-                    parsePrecedenceExpression(;, 1, true)
-                      parseUnaryExpression(;, true)
-                        parsePrimary(;, expression)
+                    parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(;, true, ConstantPatternContext.none)
+                        parsePrimary(;, expression, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
@@ -312,9 +312,9 @@
                                   parseArgumentsRest(()
                                     listener: beginArguments(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
                                                 isNextIdentifier(()
@@ -324,7 +324,7 @@
                                                 parseArgumentsOpt(record2)
                                                   listener: handleNoArguments(.)
                                                 listener: handleSend(record2, .)
-                                        parsePrimary(., expressionContinuation)
+                                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
                                               isNextIdentifier(.)

pkg/front_end/parser_testcases/record/record_literal_02.dart.intertwined.expect

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
index 18c1f8a..a625aa6 100644
--- 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
@@ -33,28 +33,28 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement({)
                     parseExpression({)
-                      parsePrecedenceExpression({, 1, true)
-                        parseUnaryExpression({, true)
-                          parsePrimary({, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({)
-                              parseParenthesizedExpressionOrRecordLiteral({, null)
+                      parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression({, true, ConstantPatternContext.none)
+                          parsePrimary({, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral({, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral({, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(42)
                                 ensureCloseParen(,, ()
@@ -69,42 +69,42 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 ensureIdentifier((, namedRecordFieldReference)
                                   listener: handleIdentifier(foo, namedRecordFieldReference)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(42)
                                 listener: handleNamedRecordField(:)
                                 ensureIdentifier(,, namedRecordFieldReference)
                                   listener: handleIdentifier(bar, namedRecordFieldReference)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(42)
                                 listener: handleNamedRecordField(:)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(42)
                                 ensureIdentifier(,, namedRecordFieldReference)
                                   listener: handleIdentifier(baz, namedRecordFieldReference)
                                 parseExpression(:)
-                                  parsePrecedenceExpression(:, 1, true)
-                                    parseUnaryExpression(:, true)
-                                      parsePrimary(:, expression)
+                                  parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                      parsePrimary(:, expression, ConstantPatternContext.none)
                                         parseLiteralInt(:)
                                           listener: handleLiteralInt(42)
                                 listener: handleNamedRecordField(:)
@@ -120,37 +120,37 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                          parseParenthesizedExpressionOrRecordLiteral((, null)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                          parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(()
                                                       listener: handleLiteralInt(42)
                                             parseExpression(,)
-                                              parsePrecedenceExpression(,, 1, true)
-                                                parseUnaryExpression(,, true)
-                                                  parsePrimary(,, expression)
+                                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                                     parseLiteralInt(,)
                                                       listener: handleLiteralInt(42)
                                             ensureCloseParen(42, ()
                                             listener: endRecordLiteral((, 2, null)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(42)
                                 ensureCloseParen(42, ()
@@ -165,17 +165,17 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
-                              parseParenthesizedExpressionOrRecordLiteral(;, null)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(;, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
-                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
                                           listener: handleNoTypeVariables(()
                                           parseFunctionExpression(()
                                             listener: beginFunctionExpression(()
@@ -210,18 +210,18 @@
                                               parseFunctionBody(), true, false)
                                                 parseExpressionFunctionBody(=>, true)
                                                   parseExpression(=>)
-                                                    parsePrecedenceExpression(=>, 1, true)
-                                                      parseUnaryExpression(=>, true)
-                                                        parsePrimary(=>, expression)
+                                                    parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                                        parsePrimary(=>, expression, ConstantPatternContext.none)
                                                           parseLiteralInt(=>)
                                                             listener: handleLiteralInt(42)
                                                   listener: handleExpressionFunctionBody(=>, null)
                                                   inGenerator()
                                             listener: endFunctionExpression((, ,)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(42)
                                 ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_literal_03.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_literal_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_literal_03.dart.intertwined.expect
index 2d0fb44..3dadf68 100644
--- a/pkg/front_end/parser_testcases/record/record_literal_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_literal_03.dart.intertwined.expect
@@ -42,16 +42,16 @@
                     parseVariableInitializerOpt(r1)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(42)
                                   ensureCloseParen(,, ()
@@ -77,18 +77,18 @@
                     parseVariableInitializerOpt(r2)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureIdentifier((, namedRecordFieldReference)
                                     listener: handleIdentifier(hello, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(42)
                                   listener: handleNamedRecordField(:)
@@ -115,18 +115,18 @@
                     parseVariableInitializerOpt(r3)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureIdentifier((, namedRecordFieldReference)
                                     listener: handleIdentifier(hello, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(42)
                                   listener: handleNamedRecordField(:)
@@ -153,16 +153,16 @@
                     parseVariableInitializerOpt(r4)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                parseParenthesizedExpressionOrRecordLiteral(=, null)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(42)
                                   ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_literal_04.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_literal_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_literal_04.dart.intertwined.expect
index 576112b..de91a6d 100644
--- a/pkg/front_end/parser_testcases/record/record_literal_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_literal_04.dart.intertwined.expect
@@ -42,17 +42,17 @@
                     parseVariableInitializerOpt(r1)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseConstExpression(=)
                                 listener: beginConstLiteral(()
-                                parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(42)
                                   ensureCloseParen(,, ()
@@ -79,40 +79,40 @@
                     parseVariableInitializerOpt(r2)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseConstExpression(=)
                                 listener: beginConstLiteral(()
-                                parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(1)
                                   parseExpression(,)
-                                    parsePrecedenceExpression(,, 1, true)
-                                      parseUnaryExpression(,, true)
-                                        parsePrimary(,, expression)
+                                    parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                        parsePrimary(,, expression, ConstantPatternContext.none)
                                           parseLiteralInt(,)
                                             listener: handleLiteralInt(2)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(a, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(3)
                                   listener: handleNamedRecordField(:)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(b, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(4)
                                   listener: handleNamedRecordField(:)
@@ -140,40 +140,40 @@
                     parseVariableInitializerOpt(r3)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseConstExpression(=)
                                 listener: beginConstLiteral(()
-                                parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(1)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(a, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(2)
                                   listener: handleNamedRecordField(:)
                                   parseExpression(,)
-                                    parsePrecedenceExpression(,, 1, true)
-                                      parseUnaryExpression(,, true)
-                                        parsePrimary(,, expression)
+                                    parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                        parsePrimary(,, expression, ConstantPatternContext.none)
                                           parseLiteralInt(,)
                                             listener: handleLiteralInt(3)
                                   ensureIdentifier(,, namedRecordFieldReference)
                                     listener: handleIdentifier(b, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(4)
                                   listener: handleNamedRecordField(:)
@@ -201,19 +201,19 @@
                     parseVariableInitializerOpt(r4)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseConstExpression(=)
                                 listener: beginConstLiteral(()
-                                parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureIdentifier((, namedRecordFieldReference)
                                     listener: handleIdentifier(hello, namedRecordFieldReference)
                                   parseExpression(:)
-                                    parsePrecedenceExpression(:, 1, true)
-                                      parseUnaryExpression(:, true)
-                                        parsePrimary(:, expression)
+                                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                        parsePrimary(:, expression, ConstantPatternContext.none)
                                           parseLiteralInt(:)
                                             listener: handleLiteralInt(42)
                                   listener: handleNamedRecordField(:)
@@ -241,17 +241,17 @@
                     parseVariableInitializerOpt(r5)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseConstExpression(=)
                                 listener: beginConstLiteral(()
-                                parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(42)
                                   ensureCloseParen(42, ()
@@ -280,12 +280,12 @@
                     parseVariableInitializerOpt(r6)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseConstExpression(=)
                                 listener: beginConstLiteral(()
-                                parseParenthesizedExpressionOrRecordLiteral(const, const)
+                                parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   ensureCloseParen((, ()
                                   listener: endRecordLiteral((, 0, const)
@@ -329,22 +329,22 @@
                     listener: handleIdentifier(record1, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -364,23 +364,23 @@
                     listener: handleIdentifier(record2, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
                           parseConstExpression(=)
                             listener: beginConstLiteral(()
-                            parseParenthesizedExpressionOrRecordLiteral(const, const)
+                            parseParenthesizedExpressionOrRecordLiteral(const, const, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_type_01.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_01.dart.intertwined.expect
index 9d8e02a..74e55eb 100644
--- a/pkg/front_end/parser_testcases/record/record_type_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_01.dart.intertwined.expect
@@ -65,22 +65,22 @@
                       parseVariableInitializerOpt(record1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureCloseParen(2, ()
@@ -131,22 +131,22 @@
                       parseVariableInitializerOpt(record1Named)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureCloseParen(2, ()
@@ -195,22 +195,22 @@
                       parseVariableInitializerOpt(record2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureCloseParen(2, ()
@@ -261,22 +261,22 @@
                       parseVariableInitializerOpt(record2Named)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureCloseParen(2, ()
@@ -351,39 +351,39 @@
                       parseVariableInitializerOpt(record3)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(a, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(3)
                                     listener: handleNamedRecordField(:)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(b, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(4)
                                     listener: handleNamedRecordField(:)
@@ -461,39 +461,39 @@
                       parseVariableInitializerOpt(record3Named)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(a, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(3)
                                     listener: handleNamedRecordField(:)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(b, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(4)
                                     listener: handleNamedRecordField(:)
@@ -569,39 +569,39 @@
                       parseVariableInitializerOpt(record4)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(a, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(3)
                                     listener: handleNamedRecordField(:)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(b, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(4)
                                     listener: handleNamedRecordField(:)
@@ -679,39 +679,39 @@
                       parseVariableInitializerOpt(record4Named)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(a, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(3)
                                     listener: handleNamedRecordField(:)
                                     ensureIdentifier(,, namedRecordFieldReference)
                                       listener: handleIdentifier(b, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(4)
                                     listener: handleNamedRecordField(:)
@@ -830,37 +830,37 @@
                       parseVariableInitializerOpt(record5)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
-                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(()
-                                              parseParenthesizedExpressionOrRecordLiteral((, null)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
+                                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral((, ConstantPatternContext.none)
+                                              parseParenthesizedExpressionOrRecordLiteral((, null, ConstantPatternContext.none)
                                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(()
                                                           listener: handleLiteralInt(1)
                                                 parseExpression(,)
-                                                  parsePrecedenceExpression(,, 1, true)
-                                                    parseUnaryExpression(,, true)
-                                                      parsePrimary(,, expression)
+                                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                                         parseLiteralInt(,)
                                                           listener: handleLiteralInt(2)
                                                 ensureCloseParen(2, ()
                                                 listener: endRecordLiteral((, 2, null)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureCloseParen(2, ()
@@ -930,9 +930,9 @@
                             looksLikeLocalFunction(print)
                             parseExpressionStatement({)
                               parseExpression({)
-                                parsePrecedenceExpression({, 1, true)
-                                  parseUnaryExpression({, true)
-                                    parsePrimary({, expression)
+                                parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression({, true, ConstantPatternContext.none)
+                                    parsePrimary({, expression, ConstantPatternContext.none)
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
@@ -945,9 +945,9 @@
                                               parseArgumentsRest(()
                                                 listener: beginArguments(()
                                                 parseExpression(()
-                                                  parsePrecedenceExpression((, 1, true)
-                                                    parseUnaryExpression((, true)
-                                                      parsePrimary((, expression)
+                                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                      parsePrimary((, expression, ConstantPatternContext.none)
                                                         parseLiteralString(()
                                                           parseSingleLiteralString(()
                                                             listener: beginLiteralString("sync named async with int return type taking 2 parameters")
@@ -1043,9 +1043,9 @@
                               looksLikeLocalFunction(print)
                               parseExpressionStatement({)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral({, expression)
                                           looksLikeFunctionBody(;)
                                           parseSend({, expression)
@@ -1058,9 +1058,9 @@
                                                 parseArgumentsRest(()
                                                   listener: beginArguments(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseLiteralString(()
                                                             parseSingleLiteralString(()
                                                               listener: beginLiteralString("sync named async with record type return type taking 2 parameters")
@@ -1150,9 +1150,9 @@
                       parseFunctionBody(), false, false)
                         parseExpressionFunctionBody(=>, false)
                           parseExpression(=>)
-                            parsePrecedenceExpression(=>, 1, true)
-                              parseUnaryExpression(=>, true)
-                                parsePrimary(=>, expression)
+                            parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                              parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                parsePrimary(=>, expression, ConstantPatternContext.none)
                                   parseSendOrFunctionLiteral(=>, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(=>, expression)
@@ -1165,9 +1165,9 @@
                                           parseArgumentsRest(()
                                             listener: beginArguments(()
                                             parseExpression(()
-                                              parsePrecedenceExpression((, 1, true)
-                                                parseUnaryExpression((, true)
-                                                  parsePrimary((, expression)
+                                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                  parsePrimary((, expression, ConstantPatternContext.none)
                                                     parseLiteralString(()
                                                       parseSingleLiteralString(()
                                                         listener: beginLiteralString("sync named async with record type return type taking 2 parameters")
@@ -1186,10 +1186,10 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(;)
                                 listener: beginFunctionExpression(()
@@ -1234,9 +1234,9 @@
                                           looksLikeLocalFunction(print)
                                           parseExpressionStatement({)
                                             parseExpression({)
-                                              parsePrecedenceExpression({, 1, true)
-                                                parseUnaryExpression({, true)
-                                                  parsePrimary({, expression)
+                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral({, expression)
                                                       looksLikeFunctionBody(;)
                                                       parseSend({, expression)
@@ -1249,9 +1249,9 @@
                                                             parseArgumentsRest(()
                                                               listener: beginArguments(()
                                                               parseExpression(()
-                                                                parsePrecedenceExpression((, 1, true)
-                                                                  parseUnaryExpression((, true)
-                                                                    parsePrimary((, expression)
+                                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                                       parseLiteralString(()
                                                                         parseSingleLiteralString(()
                                                                           listener: beginLiteralString("sync unnamed taking 2 parameters")
@@ -1280,10 +1280,10 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(;)
                                 listener: beginFunctionExpression(()
@@ -1322,9 +1322,9 @@
                                   parseFunctionBody(), true, false)
                                     parseExpressionFunctionBody(=>, true)
                                       parseExpression(=>)
-                                        parsePrecedenceExpression(=>, 1, true)
-                                          parseUnaryExpression(=>, true)
-                                            parsePrimary(=>, expression)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(=>, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend(=>, expression)
@@ -1337,9 +1337,9 @@
                                                       parseArgumentsRest(()
                                                         listener: beginArguments(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("sync unnamed taking 2 parameters")
@@ -1359,10 +1359,10 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(;)
                                 listener: beginFunctionExpression(()
@@ -1407,9 +1407,9 @@
                                           looksLikeLocalFunction(print)
                                           parseExpressionStatement({)
                                             parseExpression({)
-                                              parsePrecedenceExpression({, 1, true)
-                                                parseUnaryExpression({, true)
-                                                  parsePrimary({, expression)
+                                              parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                                parseUnaryExpression({, true, ConstantPatternContext.none)
+                                                  parsePrimary({, expression, ConstantPatternContext.none)
                                                     parseSendOrFunctionLiteral({, expression)
                                                       looksLikeFunctionBody(;)
                                                       parseSend({, expression)
@@ -1422,9 +1422,9 @@
                                                             parseArgumentsRest(()
                                                               listener: beginArguments(()
                                                               parseExpression(()
-                                                                parsePrecedenceExpression((, 1, true)
-                                                                  parseUnaryExpression((, true)
-                                                                    parsePrimary((, expression)
+                                                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                                    parsePrimary((, expression, ConstantPatternContext.none)
                                                                       parseLiteralString(()
                                                                         parseSingleLiteralString(()
                                                                           listener: beginLiteralString("async unnamed taking 2 parameters")
@@ -1453,10 +1453,10 @@
                   looksLikeLocalFunction(()
                   parseExpressionStatement(;)
                     parseExpression(;)
-                      parsePrecedenceExpression(;, 1, true)
-                        parseUnaryExpression(;, true)
-                          parsePrimary(;, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;)
+                      parsePrecedenceExpression(;, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(;, true, ConstantPatternContext.none)
+                          parsePrimary(;, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(;, ConstantPatternContext.none)
                               listener: handleNoTypeVariables(()
                               parseFunctionExpression(;)
                                 listener: beginFunctionExpression(()
@@ -1495,9 +1495,9 @@
                                   parseFunctionBody(async, true, false)
                                     parseExpressionFunctionBody(=>, true)
                                       parseExpression(=>)
-                                        parsePrecedenceExpression(=>, 1, true)
-                                          parseUnaryExpression(=>, true)
-                                            parsePrimary(=>, expression)
+                                        parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                                          parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                                            parsePrimary(=>, expression, ConstantPatternContext.none)
                                               parseSendOrFunctionLiteral(=>, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend(=>, expression)
@@ -1510,9 +1510,9 @@
                                                       parseArgumentsRest(()
                                                         listener: beginArguments(()
                                                         parseExpression(()
-                                                          parsePrecedenceExpression((, 1, true)
-                                                            parseUnaryExpression((, true)
-                                                              parsePrimary((, expression)
+                                                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                              parsePrimary((, expression, ConstantPatternContext.none)
                                                                 parseLiteralString(()
                                                                   parseSingleLiteralString(()
                                                                     listener: beginLiteralString("async unnamed taking 2 parameters")

pkg/front_end/parser_testcases/record/record_type_02.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_02.dart.intertwined.expect
index 9c5fa95..627f352 100644
--- a/pkg/front_end/parser_testcases/record/record_type_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_02.dart.intertwined.expect
@@ -71,22 +71,22 @@
                       parseVariableInitializerOpt(record1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralInt(,)
                                               listener: handleLiteralInt(2)
                                     ensureCloseParen(2, ()
@@ -127,16 +127,16 @@
                       parseVariableInitializerOpt(record2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     ensureCloseParen(,, ()
@@ -202,16 +202,16 @@
                       parseVariableInitializerOpt(record1)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(1)
                                     ensureCloseParen(,, ()
@@ -255,18 +255,18 @@
                       parseVariableInitializerOpt(record2)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureIdentifier((, namedRecordFieldReference)
                                       listener: handleIdentifier(ok, namedRecordFieldReference)
                                     parseExpression(:)
-                                      parsePrecedenceExpression(:, 1, true)
-                                        parseUnaryExpression(:, true)
-                                          parsePrimary(:, expression)
+                                      parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(:, true, ConstantPatternContext.none)
+                                          parsePrimary(:, expression, ConstantPatternContext.none)
                                             parseLiteralInt(:)
                                               listener: handleLiteralInt(1)
                                     listener: handleNamedRecordField(:)
@@ -296,11 +296,11 @@
                       parseVariableInitializerOpt(record3)
                         listener: beginVariableInitializer(=)
                         parseExpression(=)
-                          parsePrecedenceExpression(=, 1, true)
-                            parseUnaryExpression(=, true)
-                              parsePrimary(=, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                                  parseParenthesizedExpressionOrRecordLiteral(=, null)
+                          parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(=, true, ConstantPatternContext.none)
+                              parsePrimary(=, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     ensureCloseParen((, ()
                                     listener: endRecordLiteral((, 0, null)

pkg/front_end/parser_testcases/record/record_type_03.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_03.dart.intertwined.expect
index 499619b..e732c3f 100644
--- a/pkg/front_end/parser_testcases/record/record_type_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_03.dart.intertwined.expect
@@ -104,9 +104,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -116,7 +116,7 @@
                                 parseArgumentsOpt(inputRecord)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(inputRecord, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -135,22 +135,22 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                parseParenthesizedExpressionOrRecordLiteral(return, null)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(42)
                                   parseExpression(,)
-                                    parsePrecedenceExpression(,, 1, true)
-                                      parseUnaryExpression(,, true)
-                                        parsePrimary(,, expression)
+                                    parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                        parsePrimary(,, expression, ConstantPatternContext.none)
                                           parseLiteralInt(,)
                                             listener: handleLiteralInt(42)
                                   ensureCloseParen(42, ()
@@ -166,22 +166,22 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
-                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                          parseParenthesizedExpressionOrRecordLiteral(return, null)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
+                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                          parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(1)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseLiteralInt(,)
                                       listener: handleLiteralInt(1)
                             ensureCloseParen(,, ()
@@ -283,9 +283,9 @@
                 ensureParenthesizedCondition(if, allowCase: false)
                   parseExpressionInParenthesisRest((, allowCase: false)
                     parseExpression(()
-                      parsePrecedenceExpression((, 1, true)
-                        parseUnaryExpression((, true)
-                          parsePrimary((, expression)
+                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                          parsePrimary((, expression, ConstantPatternContext.none)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
                                 isNextIdentifier(()
@@ -295,7 +295,7 @@
                                 parseArgumentsOpt(inputRecord)
                                   listener: handleNoArguments(.)
                                 listener: handleSend(inputRecord, .)
-                        parsePrimary(., expressionContinuation)
+                        parsePrimary(., expressionContinuation, ConstantPatternContext.none)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
                               isNextIdentifier(.)
@@ -314,22 +314,22 @@
                     parseReturnStatement())
                       listener: beginReturnStatement(return)
                       parseExpression(return)
-                        parsePrecedenceExpression(return, 1, true)
-                          parseUnaryExpression(return, true)
-                            parsePrimary(return, expression)
-                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                parseParenthesizedExpressionOrRecordLiteral(return, null)
+                        parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(return, true, ConstantPatternContext.none)
+                            parsePrimary(return, expression, ConstantPatternContext.none)
+                              parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                   listener: beginParenthesizedExpressionOrRecordLiteral(()
                                   parseExpression(()
-                                    parsePrecedenceExpression((, 1, true)
-                                      parseUnaryExpression((, true)
-                                        parsePrimary((, expression)
+                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                        parsePrimary((, expression, ConstantPatternContext.none)
                                           parseLiteralInt(()
                                             listener: handleLiteralInt(42)
                                   parseExpression(,)
-                                    parsePrecedenceExpression(,, 1, true)
-                                      parseUnaryExpression(,, true)
-                                        parsePrimary(,, expression)
+                                    parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                      parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                        parsePrimary(,, expression, ConstantPatternContext.none)
                                           parseLiteralInt(,)
                                             listener: handleLiteralInt(42)
                                   ensureCloseParen(42, ()
@@ -345,22 +345,22 @@
               parseReturnStatement(;)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
-                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                          parseParenthesizedExpressionOrRecordLiteral(return, null)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
+                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                          parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(1)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseLiteralInt(,)
                                       listener: handleLiteralInt(1)
                             ensureCloseParen(,, ()
@@ -457,22 +457,22 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralInt(,)
                                           listener: handleLiteralInt(42)
                                 ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_type_as_named_parameter.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_as_named_parameter.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_as_named_parameter.dart.intertwined.expect
index 7e585e0..b6f6313 100644
--- a/pkg/front_end/parser_testcases/record/record_type_as_named_parameter.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_as_named_parameter.dart.intertwined.expect
@@ -148,22 +148,22 @@
                     listener: handleIdentifier(foo1, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                            parseParenthesizedExpressionOrRecordLiteral(:, null)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -203,22 +203,22 @@
                     listener: handleIdentifier(foo2, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(:)
-                    parsePrecedenceExpression(:, 1, true)
-                      parseUnaryExpression(:, true)
-                        parsePrimary(:, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:)
-                            parseParenthesizedExpressionOrRecordLiteral(:, null)
+                    parsePrecedenceExpression(:, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(:, true, ConstantPatternContext.none)
+                        parsePrimary(:, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(:, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(:, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -289,22 +289,22 @@
                     listener: handleIdentifier(foo1, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -344,22 +344,22 @@
                     listener: handleIdentifier(foo2, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_type_as_optional_parameter.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_as_optional_parameter.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_as_optional_parameter.dart.intertwined.expect
index 35eb14f..a9cdce5 100644
--- a/pkg/front_end/parser_testcases/record/record_type_as_optional_parameter.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_as_optional_parameter.dart.intertwined.expect
@@ -148,22 +148,22 @@
                     listener: handleIdentifier(foo1, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -203,22 +203,22 @@
                     listener: handleIdentifier(foo2, formalParameterDeclaration)
                   listener: beginFormalParameterDefaultValueExpression()
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()

pkg/front_end/parser_testcases/record/record_type_as_type_arguments.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_as_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_as_type_arguments.dart.intertwined.expect
index 49f23e7..25c4fbf 100644
--- a/pkg/front_end/parser_testcases/record/record_type_as_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_as_type_arguments.dart.intertwined.expect
@@ -42,9 +42,9 @@
                     parseVariableInitializerOpt(x)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               parseLiteralListSetMapOrFunction(=, null)
                                 listener: beginTypeArguments(<)
                                 parseRecordType((, <, false)
@@ -124,9 +124,9 @@
                     parseVariableInitializerOpt(y)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([])
                               parseLiteralListSuffix(=, null)
                                 rewriteSquareBrackets(=)
@@ -204,9 +204,9 @@
                     parseVariableInitializerOpt(z)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(=, null)
                                 listener: handleLiteralSetOrMap(0, {, null, }, false)
@@ -315,9 +315,9 @@
                     parseVariableInitializerOpt(y2)
                       listener: beginVariableInitializer(=)
                       parseExpression(=)
-                        parsePrecedenceExpression(=, 1, true)
-                          parseUnaryExpression(=, true)
-                            parsePrimary(=, expression)
+                        parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                          parseUnaryExpression(=, true, ConstantPatternContext.none)
+                            parsePrimary(=, expression, ConstantPatternContext.none)
                               listener: handleNoTypeArguments([])
                               parseLiteralListSuffix(=, null)
                                 rewriteSquareBrackets(=)

pkg/front_end/parser_testcases/record/record_type_getter.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_getter.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_getter.dart.intertwined.expect
index 501ab16..2db3a4d 100644
--- a/pkg/front_end/parser_testcases/record/record_type_getter.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_getter.dart.intertwined.expect
@@ -62,22 +62,22 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -154,22 +154,22 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
-                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                          parseParenthesizedExpressionOrRecordLiteral(return, null)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
+                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                          parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseLiteralString(,)
                                       parseSingleLiteralString(,)
                                         listener: beginLiteralString("fortytwo")
@@ -245,9 +245,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -327,9 +327,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -403,9 +403,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -486,9 +486,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -562,9 +562,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -645,9 +645,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -704,22 +704,22 @@
         parseFunctionBody(get, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -781,22 +781,22 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
-                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                          parseParenthesizedExpressionOrRecordLiteral(return, null)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
+                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                          parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseLiteralString(,)
                                       parseSingleLiteralString(,)
                                         listener: beginLiteralString("fortytwo")
@@ -857,9 +857,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -924,9 +924,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -985,9 +985,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -1053,9 +1053,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -1114,9 +1114,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -1182,9 +1182,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -1241,22 +1241,22 @@
         parseFunctionBody(topLevelGetter, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -1318,22 +1318,22 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
-                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                          parseParenthesizedExpressionOrRecordLiteral(return, null)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
+                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                          parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseLiteralString(,)
                                       parseSingleLiteralString(,)
                                         listener: beginLiteralString("fortytwo")
@@ -1394,9 +1394,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -1461,9 +1461,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -1522,9 +1522,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -1590,9 +1590,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -1651,9 +1651,9 @@
             parseExpression(=>)
               parseThrowExpression(=>, true)
                 parseExpression(throw)
-                  parsePrecedenceExpression(throw, 1, true)
-                    parseUnaryExpression(throw, true)
-                      parsePrimary(throw, expression)
+                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                      parsePrimary(throw, expression, ConstantPatternContext.none)
                         parseLiteralString(throw)
                           parseSingleLiteralString(throw)
                             listener: beginLiteralString("hello")
@@ -1719,9 +1719,9 @@
                     parseExpression({)
                       parseThrowExpression({, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -1821,22 +1821,22 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -1918,22 +1918,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("fortytwo")
@@ -2014,9 +2014,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -2101,9 +2101,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -2182,9 +2182,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -2270,9 +2270,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -2351,9 +2351,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -2439,9 +2439,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -2502,22 +2502,22 @@
                 parseFunctionBody(get, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -2583,22 +2583,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("fortytwo")
@@ -2663,9 +2663,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -2734,9 +2734,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -2799,9 +2799,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -2871,9 +2871,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -2936,9 +2936,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -3008,9 +3008,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -3071,22 +3071,22 @@
                 parseFunctionBody(instanceGetter, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -3152,22 +3152,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("fortytwo")
@@ -3232,9 +3232,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -3301,9 +3301,9 @@
                         parseExpression(return)
                           parseThrowExpression(return, true)
                             parseExpression(throw)
-                              parsePrecedenceExpression(throw, 1, true)
-                                parseUnaryExpression(throw, true)
-                                  parsePrimary(throw, expression)
+                              parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                  parsePrimary(throw, expression, ConstantPatternContext.none)
                                     parseLiteralString(throw)
                                       parseSingleLiteralString(throw)
                                         listener: beginLiteralString("hello")
@@ -3367,9 +3367,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -3437,9 +3437,9 @@
                         parseExpression(return)
                           parseThrowExpression(return, true)
                             parseExpression(throw)
-                              parsePrecedenceExpression(throw, 1, true)
-                                parseUnaryExpression(throw, true)
-                                  parsePrimary(throw, expression)
+                              parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                  parsePrimary(throw, expression, ConstantPatternContext.none)
                                     parseLiteralString(throw)
                                       parseSingleLiteralString(throw)
                                         listener: beginLiteralString("hello")
@@ -3504,9 +3504,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -3574,9 +3574,9 @@
                         parseExpression(return)
                           parseThrowExpression(return, true)
                             parseExpression(throw)
-                              parsePrecedenceExpression(throw, 1, true)
-                                parseUnaryExpression(throw, true)
-                                  parsePrimary(throw, expression)
+                              parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                  parsePrimary(throw, expression, ConstantPatternContext.none)
                                     parseLiteralString(throw)
                                       parseSingleLiteralString(throw)
                                         listener: beginLiteralString("hello")
@@ -3681,22 +3681,22 @@
                 parseFunctionBody(), false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -3777,22 +3777,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("fortytwo")
@@ -3872,9 +3872,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -3958,9 +3958,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -4038,9 +4038,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -4125,9 +4125,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -4205,9 +4205,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -4292,9 +4292,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -4354,22 +4354,22 @@
                 parseFunctionBody(get, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -4434,22 +4434,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("fortytwo")
@@ -4513,9 +4513,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -4583,9 +4583,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -4647,9 +4647,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -4718,9 +4718,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -4782,9 +4782,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -4853,9 +4853,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -4915,22 +4915,22 @@
                 parseFunctionBody(staticGetter, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -4995,22 +4995,22 @@
                       parseReturnStatement({)
                         listener: beginReturnStatement(return)
                         parseExpression(return)
-                          parsePrecedenceExpression(return, 1, true)
-                            parseUnaryExpression(return, true)
-                              parsePrimary(return, expression)
-                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                                  parseParenthesizedExpressionOrRecordLiteral(return, null)
+                          parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(return, true, ConstantPatternContext.none)
+                              parsePrimary(return, expression, ConstantPatternContext.none)
+                                parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                                  parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                                     listener: beginParenthesizedExpressionOrRecordLiteral(()
                                     parseExpression(()
-                                      parsePrecedenceExpression((, 1, true)
-                                        parseUnaryExpression((, true)
-                                          parsePrimary((, expression)
+                                      parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression((, true, ConstantPatternContext.none)
+                                          parsePrimary((, expression, ConstantPatternContext.none)
                                             parseLiteralInt(()
                                               listener: handleLiteralInt(42)
                                     parseExpression(,)
-                                      parsePrecedenceExpression(,, 1, true)
-                                        parseUnaryExpression(,, true)
-                                          parsePrimary(,, expression)
+                                      parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                        parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                          parsePrimary(,, expression, ConstantPatternContext.none)
                                             parseLiteralString(,)
                                               parseSingleLiteralString(,)
                                                 listener: beginLiteralString("fortytwo")
@@ -5074,9 +5074,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -5144,9 +5144,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -5208,9 +5208,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -5279,9 +5279,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")
@@ -5343,9 +5343,9 @@
                     parseExpression(=>)
                       parseThrowExpression(=>, true)
                         parseExpression(throw)
-                          parsePrecedenceExpression(throw, 1, true)
-                            parseUnaryExpression(throw, true)
-                              parsePrimary(throw, expression)
+                          parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                              parsePrimary(throw, expression, ConstantPatternContext.none)
                                 parseLiteralString(throw)
                                   parseSingleLiteralString(throw)
                                     listener: beginLiteralString("hello")
@@ -5414,9 +5414,9 @@
                             parseExpression({)
                               parseThrowExpression({, true)
                                 parseExpression(throw)
-                                  parsePrecedenceExpression(throw, 1, true)
-                                    parseUnaryExpression(throw, true)
-                                      parsePrimary(throw, expression)
+                                  parsePrecedenceExpression(throw, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(throw, true, ConstantPatternContext.none)
+                                      parsePrimary(throw, expression, ConstantPatternContext.none)
                                         parseLiteralString(throw)
                                           parseSingleLiteralString(throw)
                                             listener: beginLiteralString("hello")

pkg/front_end/parser_testcases/record/record_type_in_for_loop.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_in_for_loop.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_in_for_loop.dart.intertwined.expect
index a9b35a7..bbf3440c 100644
--- a/pkg/front_end/parser_testcases/record/record_type_in_for_loop.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_in_for_loop.dart.intertwined.expect
@@ -75,49 +75,49 @@
                   parseForInLoopPartsRest(x, null, for, null, x)
                     listener: beginForInExpression([)
                     parseExpression(in)
-                      parsePrecedenceExpression(in, 1, true)
-                        parseUnaryExpression(in, true)
-                          parsePrimary(in, expression)
+                      parsePrecedenceExpression(in, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(in, true, ConstantPatternContext.none)
+                          parsePrimary(in, expression, ConstantPatternContext.none)
                             listener: handleNoTypeArguments([)
                             parseLiteralListSuffix(in, null)
                               parseExpression([)
-                                parsePrecedenceExpression([, 1, true)
-                                  parseUnaryExpression([, true)
-                                    parsePrimary([, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([)
-                                        parseParenthesizedExpressionOrRecordLiteral([, null)
+                                parsePrecedenceExpression([, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression([, true, ConstantPatternContext.none)
+                                    parsePrimary([, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral([, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral([, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(()
                                                     listener: handleLiteralInt(42)
                                           parseExpression(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(,)
                                                     listener: handleLiteralInt(42)
                                           ensureCloseParen(42, ()
                                           listener: endRecordLiteral((, 2, null)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
-                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,)
-                                        parseParenthesizedExpressionOrRecordLiteral(,, null)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
+                                      parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(,, ConstantPatternContext.none)
+                                        parseParenthesizedExpressionOrRecordLiteral(,, null, ConstantPatternContext.none)
                                           listener: beginParenthesizedExpressionOrRecordLiteral(()
                                           parseExpression(()
-                                            parsePrecedenceExpression((, 1, true)
-                                              parseUnaryExpression((, true)
-                                                parsePrimary((, expression)
+                                            parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                parsePrimary((, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(()
                                                     listener: handleLiteralInt(21)
                                           parseExpression(,)
-                                            parsePrecedenceExpression(,, 1, true)
-                                              parseUnaryExpression(,, true)
-                                                parsePrimary(,, expression)
+                                            parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                              parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                                parsePrimary(,, expression, ConstantPatternContext.none)
                                                   parseLiteralInt(,)
                                                     listener: handleLiteralInt(21)
                                           ensureCloseParen(21, ()
@@ -139,9 +139,9 @@
                               looksLikeLocalFunction(print)
                               parseExpressionStatement({)
                                 parseExpression({)
-                                  parsePrecedenceExpression({, 1, true)
-                                    parseUnaryExpression({, true)
-                                      parsePrimary({, expression)
+                                  parsePrecedenceExpression({, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression({, true, ConstantPatternContext.none)
+                                      parsePrimary({, expression, ConstantPatternContext.none)
                                         parseSendOrFunctionLiteral({, expression)
                                           looksLikeFunctionBody(;)
                                           parseSend({, expression)
@@ -154,9 +154,9 @@
                                                 parseArgumentsRest(()
                                                   listener: beginArguments(()
                                                   parseExpression(()
-                                                    parsePrecedenceExpression((, 1, true)
-                                                      parseUnaryExpression((, true)
-                                                        parsePrimary((, expression)
+                                                    parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                                      parseUnaryExpression((, true, ConstantPatternContext.none)
+                                                        parsePrimary((, expression, ConstantPatternContext.none)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
                                                               isNextIdentifier(()

pkg/front_end/parser_testcases/record/record_type_return_on_function_with_type_parameter.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_return_on_function_with_type_parameter.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_return_on_function_with_type_parameter.dart.intertwined.expect
index 6ad0a73..f9d089a 100644
--- a/pkg/front_end/parser_testcases/record/record_type_return_on_function_with_type_parameter.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_return_on_function_with_type_parameter.dart.intertwined.expect
@@ -73,22 +73,22 @@
               parseReturnStatement({)
                 listener: beginReturnStatement(return)
                 parseExpression(return)
-                  parsePrecedenceExpression(return, 1, true)
-                    parseUnaryExpression(return, true)
-                      parsePrimary(return, expression)
-                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return)
-                          parseParenthesizedExpressionOrRecordLiteral(return, null)
+                  parsePrecedenceExpression(return, 1, true, ConstantPatternContext.none)
+                    parseUnaryExpression(return, true, ConstantPatternContext.none)
+                      parsePrimary(return, expression, ConstantPatternContext.none)
+                        parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(return, ConstantPatternContext.none)
+                          parseParenthesizedExpressionOrRecordLiteral(return, null, ConstantPatternContext.none)
                             listener: beginParenthesizedExpressionOrRecordLiteral(()
                             parseExpression(()
-                              parsePrecedenceExpression((, 1, true)
-                                parseUnaryExpression((, true)
-                                  parsePrimary((, expression)
+                              parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression((, true, ConstantPatternContext.none)
+                                  parsePrimary((, expression, ConstantPatternContext.none)
                                     parseLiteralInt(()
                                       listener: handleLiteralInt(42)
                             parseExpression(,)
-                              parsePrecedenceExpression(,, 1, true)
-                                parseUnaryExpression(,, true)
-                                  parsePrimary(,, expression)
+                              parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                  parsePrimary(,, expression, ConstantPatternContext.none)
                                     parseSendOrFunctionLiteral(,, expression)
                                       parseSend(,, expression)
                                         isNextIdentifier(,)
@@ -173,22 +173,22 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
                                     isNextIdentifier(,)

pkg/front_end/parser_testcases/record/record_type_setter.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_setter.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_setter.dart.intertwined.expect
index 6a3b27b..54e216f 100644
--- a/pkg/front_end/parser_testcases/record/record_type_setter.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_setter.dart.intertwined.expect
@@ -62,22 +62,22 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -147,22 +147,22 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -219,22 +219,22 @@
         parseFunctionBody(set, false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -304,22 +304,22 @@
         parseFunctionBody(), false, false)
           parseExpressionFunctionBody(=>, false)
             parseExpression(=>)
-              parsePrecedenceExpression(=>, 1, true)
-                parseUnaryExpression(=>, true)
-                  parsePrimary(=>, expression)
-                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                      parseParenthesizedExpressionOrRecordLiteral(=>, null)
+              parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                  parsePrimary(=>, expression, ConstantPatternContext.none)
+                    parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                      parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                         listener: beginParenthesizedExpressionOrRecordLiteral(()
                         parseExpression(()
-                          parsePrecedenceExpression((, 1, true)
-                            parseUnaryExpression((, true)
-                              parsePrimary((, expression)
+                          parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression((, true, ConstantPatternContext.none)
+                              parsePrimary((, expression, ConstantPatternContext.none)
                                 parseLiteralInt(()
                                   listener: handleLiteralInt(42)
                         parseExpression(,)
-                          parsePrecedenceExpression(,, 1, true)
-                            parseUnaryExpression(,, true)
-                              parsePrimary(,, expression)
+                          parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                            parseUnaryExpression(,, true, ConstantPatternContext.none)
+                              parsePrimary(,, expression, ConstantPatternContext.none)
                                 parseLiteralString(,)
                                   parseSingleLiteralString(,)
                                     listener: beginLiteralString("fortytwo")
@@ -419,22 +419,22 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -508,22 +508,22 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -584,22 +584,22 @@
                 parseFunctionBody(set, false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -673,22 +673,22 @@
                 parseFunctionBody(), false, true)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -791,22 +791,22 @@
                 parseFunctionBody(), false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -879,22 +879,22 @@
                 parseFunctionBody(), false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -954,22 +954,22 @@
                 parseFunctionBody(set, false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")
@@ -1042,22 +1042,22 @@
                 parseFunctionBody(), false, false)
                   parseExpressionFunctionBody(=>, false)
                     parseExpression(=>)
-                      parsePrecedenceExpression(=>, 1, true)
-                        parseUnaryExpression(=>, true)
-                          parsePrimary(=>, expression)
-                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>)
-                              parseParenthesizedExpressionOrRecordLiteral(=>, null)
+                      parsePrecedenceExpression(=>, 1, true, ConstantPatternContext.none)
+                        parseUnaryExpression(=>, true, ConstantPatternContext.none)
+                          parsePrimary(=>, expression, ConstantPatternContext.none)
+                            parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=>, ConstantPatternContext.none)
+                              parseParenthesizedExpressionOrRecordLiteral(=>, null, ConstantPatternContext.none)
                                 listener: beginParenthesizedExpressionOrRecordLiteral(()
                                 parseExpression(()
-                                  parsePrecedenceExpression((, 1, true)
-                                    parseUnaryExpression((, true)
-                                      parsePrimary((, expression)
+                                  parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression((, true, ConstantPatternContext.none)
+                                      parsePrimary((, expression, ConstantPatternContext.none)
                                         parseLiteralInt(()
                                           listener: handleLiteralInt(42)
                                 parseExpression(,)
-                                  parsePrecedenceExpression(,, 1, true)
-                                    parseUnaryExpression(,, true)
-                                      parsePrimary(,, expression)
+                                  parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                    parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                      parsePrimary(,, expression, ConstantPatternContext.none)
                                         parseLiteralString(,)
                                           parseSingleLiteralString(,)
                                             listener: beginLiteralString("fortytwo")

pkg/front_end/parser_testcases/record/record_type_with_modifiers.dart.intertwined.expect

diff --git a/pkg/front_end/parser_testcases/record/record_type_with_modifiers.dart.intertwined.expect b/pkg/front_end/parser_testcases/record/record_type_with_modifiers.dart.intertwined.expect
index 14aec33..4d73c47 100644
--- a/pkg/front_end/parser_testcases/record/record_type_with_modifiers.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/record/record_type_with_modifiers.dart.intertwined.expect
@@ -63,22 +63,22 @@
                 parseFieldInitializerOpt(x, x, null, null, null, null, final, DeclarationKind.Class, Foo)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -124,22 +124,22 @@
                 parseFieldInitializerOpt(y, y, null, null, null, null, null, DeclarationKind.Class, Foo)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -185,22 +185,22 @@
                 parseFieldInitializerOpt(z, z, null, null, null, null, final, DeclarationKind.Class, Foo)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()
@@ -246,22 +246,22 @@
                 parseFieldInitializerOpt(b, b, null, null, null, null, const, DeclarationKind.Class, Foo)
                   listener: beginFieldInitializer(=)
                   parseExpression(=)
-                    parsePrecedenceExpression(=, 1, true)
-                      parseUnaryExpression(=, true)
-                        parsePrimary(=, expression)
-                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=)
-                            parseParenthesizedExpressionOrRecordLiteral(=, null)
+                    parsePrecedenceExpression(=, 1, true, ConstantPatternContext.none)
+                      parseUnaryExpression(=, true, ConstantPatternContext.none)
+                        parsePrimary(=, expression, ConstantPatternContext.none)
+                          parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(=, ConstantPatternContext.none)
+                            parseParenthesizedExpressionOrRecordLiteral(=, null, ConstantPatternContext.none)
                               listener: beginParenthesizedExpressionOrRecordLiteral(()
                               parseExpression(()
-                                parsePrecedenceExpression((, 1, true)
-                                  parseUnaryExpression((, true)
-                                    parsePrimary((, expression)
+                                parsePrecedenceExpression((, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression((, true, ConstantPatternContext.none)
+                                    parsePrimary((, expression, ConstantPatternContext.none)
                                       parseLiteralInt(()
                                         listener: handleLiteralInt(42)
                               parseExpression(,)
-                                parsePrecedenceExpression(,, 1, true)
-                                  parseUnaryExpression(,, true)
-                                    parsePrimary(,, expression)
+                                parsePrecedenceExpression(,, 1, true, ConstantPatternContext.none)
+                                  parseUnaryExpression(,, true, ConstantPatternContext.none)
+                                    parsePrimary(,, expression, ConstantPatternContext.none)
                                       parseLiteralInt(,)
                                         listener: handleLiteralInt(42)
                               ensureCloseParen(42, ()

pkg/front_end/test/parser_test_parser.dart

diff --git a/pkg/front_end/test/parser_test_parser.dart b/pkg/front_end/test/parser_test_parser.dart
index a49d400..46eae6d 100644
--- a/pkg/front_end/test/parser_test_parser.dart
+++ b/pkg/front_end/test/parser_test_parser.dart
@@ -12,7 +12,8 @@
 import 'package:_fe_analyzer_shared/src/parser/identifier_context.dart';
 import 'package:_fe_analyzer_shared/src/parser/listener.dart' show Listener;
 import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
-import 'package:_fe_analyzer_shared/src/parser/parser.dart' show Parser;
+import 'package:_fe_analyzer_shared/src/parser/parser.dart'
+    show ConstantPatternContext, Parser;
 import 'package:_fe_analyzer_shared/src/parser/parser_impl.dart'
     show AwaitOrYieldContext, ForPartsContext, PatternContext;
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
@@ -1610,15 +1611,16 @@
   }
 
   @override
-  Token parsePrecedenceExpression(
-      Token token, int precedence, bool allowCascades) {
+  Token parsePrecedenceExpression(Token token, int precedence,
+      bool allowCascades, ConstantPatternContext constantPatternContext) {
     doPrint('parsePrecedenceExpression('
         '$token, '
         '$precedence, '
-        '$allowCascades)');
+        '$allowCascades, '
+        '$constantPatternContext)');
     indent++;
-    var result =
-        super.parsePrecedenceExpression(token, precedence, allowCascades);
+    var result = super.parsePrecedenceExpression(
+        token, precedence, allowCascades, constantPatternContext);
     indent--;
     return result;
   }
@@ -1633,10 +1635,15 @@
   }
 
   @override
-  Token parseUnaryExpression(Token token, bool allowCascades) {
-    doPrint('parseUnaryExpression(' '$token, ' '$allowCascades)');
+  Token parseUnaryExpression(Token token, bool allowCascades,
+      ConstantPatternContext constantPatternContext) {
+    doPrint('parseUnaryExpression('
+        '$token, '
+        '$allowCascades, '
+        '$constantPatternContext)');
     indent++;
-    var result = super.parseUnaryExpression(token, allowCascades);
+    var result = super
+        .parseUnaryExpression(token, allowCascades, constantPatternContext);
     indent--;
     return result;
   }
@@ -1656,22 +1663,25 @@
   }
 
   @override
-  Token parsePrimary(Token token, IdentifierContext context) {
-    doPrint('parsePrimary(' '$token, ' '$context)');
+  Token parsePrimary(Token token, IdentifierContext context,
+      ConstantPatternContext constantPatternContext) {
+    doPrint('parsePrimary(' '$token, ' '$context, ' '$constantPatternContext)');
     indent++;
-    var result = super.parsePrimary(token, context);
+    var result = super.parsePrimary(token, context, constantPatternContext);
     indent--;
     return result;
   }
 
   @override
   Token parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(
-      Token token) {
+      Token token, ConstantPatternContext constantPatternContext) {
     doPrint('parseParenthesizedExpressionFunctionLiteralOrRecordLiteral('
-        '$token)');
+        '$token, '
+        '$constantPatternContext)');
     indent++;
-    var result =
-        super.parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(token);
+    var result = super
+        .parseParenthesizedExpressionFunctionLiteralOrRecordLiteral(
+            token, constantPatternContext);
     indent--;
     return result;
   }
@@ -1689,13 +1699,16 @@
 
   @override
   Token parseParenthesizedExpressionOrRecordLiteral(
-      Token token, Token? constKeywordForRecord) {
+      Token token,
+      Token? constKeywordForRecord,
+      ConstantPatternContext constantPatternContext) {
     doPrint('parseParenthesizedExpressionOrRecordLiteral('
         '$token, '
-        '$constKeywordForRecord)');
+        '$constKeywordForRecord, '
+        '$constantPatternContext)');
     indent++;
     var result = super.parseParenthesizedExpressionOrRecordLiteral(
-        token, constKeywordForRecord);
+        token, constKeywordForRecord, constantPatternContext);
     indent--;
     return result;
   }

pkg/front_end/test/parser_test_parser_creator.dart

diff --git a/pkg/front_end/test/parser_test_parser_creator.dart b/pkg/front_end/test/parser_test_parser_creator.dart
index 4ec475e..7a00831 100644
--- a/pkg/front_end/test/parser_test_parser_creator.dart
+++ b/pkg/front_end/test/parser_test_parser_creator.dart
@@ -50,7 +50,7 @@
 import 'package:_fe_analyzer_shared/src/parser/identifier_context.dart';
 import 'package:_fe_analyzer_shared/src/parser/listener.dart' show Listener;
 import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
-import 'package:_fe_analyzer_shared/src/parser/parser.dart' show Parser;
+import 'package:_fe_analyzer_shared/src/parser/parser.dart' show ConstantPatternContext, Parser;
 import 'package:_fe_analyzer_shared/src/parser/parser_impl.dart' show AwaitOrYieldContext, ForPartsContext, PatternContext;
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
 import 'package:_fe_analyzer_shared/src/parser/type_info.dart';

pkg/front_end/test/spell_checking_list_code.txt

diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index fbd28fd..5260ef7 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -1245,6 +1245,7 @@
 responses
 restoring
 restriction
+restricts
 resumed
 ret
 reusage

pkg/front_end/testcases/dart2wasm/yield.dart.strong.transformed.expect

diff --git a/pkg/front_end/testcases/dart2wasm/yield.dart.strong.transformed.expect b/pkg/front_end/testcases/dart2wasm/yield.dart.strong.transformed.expect
index 67d0b8c..07a0c80 100644
--- a/pkg/front_end/testcases/dart2wasm/yield.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/dart2wasm/yield.dart.strong.transformed.expect
@@ -1,8 +1,3 @@
-//
-// Problems outside component:
-//
-// pkg/front_end/testcases/dart2wasm/yield.dart: Warning: Compilation to Wasm does not support 'sync*'.
-//
 library /*isNonNullableByDefault*/;
 import self as self;
 import "dart:core" as core;

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart
new file mode 100644
index 0000000..8c5b28c
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart
@@ -0,0 +1,32 @@
+// Copyright (c) 2023, 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.
+
+inline class I {
+  final int it;
+
+  I(int x, [int? y]) : it = x + (y ?? 42);
+
+  void m(String s, [int i = 1]) {}
+}
+
+inline class I2 {
+  final int it;
+
+  I2(int x, {int? y}) : it = x + (y ?? 87);
+
+  void m(String s, {int i = 1}) {}
+}
+
+main() {
+  expect(42, I(0));
+  expect(0, I(0, 0));
+  expect(87, I2(0));
+  expect(0, I2(0, y: 0));
+}
+
+expect(expected, actual) {
+  if (expected != actual) {
+    throw 'Expected $expected, actual $actual';
+  }
+}

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.expect
new file mode 100644
index 0000000..951d3d3
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.expect
@@ -0,0 +1,50 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+inline class I /* declaredRepresentationType = core::int */ {
+  method m = self::I|m;
+  tearoff m = self::I|get#m;
+  constructor • = self::I|;
+  tearoff • = self::I|get#;
+}
+inline class I2 /* declaredRepresentationType = core::int */ {
+  method m = self::I2|m;
+  tearoff m = self::I2|get#m;
+  constructor • = self::I2|;
+  tearoff • = self::I2|get#;
+}
+static method I|(core::int x, [core::int? y = #C1]) → self::I {
+  final self::I #this = x.{core::num::+}(let final core::int? #t1 = y in #t1 == null ?{core::int} 42 : #t1{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I|get#(core::int x, [core::int? y]) → self::I
+  return self::I|(x, y);
+static method I|m(lowered final self::I #this, core::String s, [core::int i = #C2]) → void {}
+static method I|get#m(lowered final self::I #this) → (core::String, [core::int]) → void
+  return (core::String s, [core::int i = #C2]) → void => self::I|m(#this, s, i);
+static method I2|(core::int x, {core::int? y = #C1}) → self::I2 {
+  final self::I2 #this = x.{core::num::+}(let final core::int? #t2 = y in #t2 == null ?{core::int} 87 : #t2{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I2|get#(core::int x, {core::int? y}) → self::I2
+  return self::I2|(x, y: y);
+static method I2|m(lowered final self::I2 #this, core::String s, {core::int i = #C2}) → void {}
+static method I2|get#m(lowered final self::I2 #this) → (core::String, {i: core::int}) → void
+  return (core::String s, {core::int i = #C2}) → void => self::I2|m(#this, s, i: i);
+static method main() → dynamic {
+  self::expect(42, self::I|(0));
+  self::expect(0, self::I|(0, 0));
+  self::expect(87, self::I2|(0));
+  self::expect(0, self::I2|(0, y: 0));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual)) {
+    throw "Expected ${expected}, actual ${actual}";
+  }
+}
+
+constants  {
+  #C1 = null
+  #C2 = 1
+}

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.transformed.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.transformed.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.transformed.expect
new file mode 100644
index 0000000..951d3d3
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.strong.transformed.expect
@@ -0,0 +1,50 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+inline class I /* declaredRepresentationType = core::int */ {
+  method m = self::I|m;
+  tearoff m = self::I|get#m;
+  constructor • = self::I|;
+  tearoff • = self::I|get#;
+}
+inline class I2 /* declaredRepresentationType = core::int */ {
+  method m = self::I2|m;
+  tearoff m = self::I2|get#m;
+  constructor • = self::I2|;
+  tearoff • = self::I2|get#;
+}
+static method I|(core::int x, [core::int? y = #C1]) → self::I {
+  final self::I #this = x.{core::num::+}(let final core::int? #t1 = y in #t1 == null ?{core::int} 42 : #t1{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I|get#(core::int x, [core::int? y]) → self::I
+  return self::I|(x, y);
+static method I|m(lowered final self::I #this, core::String s, [core::int i = #C2]) → void {}
+static method I|get#m(lowered final self::I #this) → (core::String, [core::int]) → void
+  return (core::String s, [core::int i = #C2]) → void => self::I|m(#this, s, i);
+static method I2|(core::int x, {core::int? y = #C1}) → self::I2 {
+  final self::I2 #this = x.{core::num::+}(let final core::int? #t2 = y in #t2 == null ?{core::int} 87 : #t2{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I2|get#(core::int x, {core::int? y}) → self::I2
+  return self::I2|(x, y: y);
+static method I2|m(lowered final self::I2 #this, core::String s, {core::int i = #C2}) → void {}
+static method I2|get#m(lowered final self::I2 #this) → (core::String, {i: core::int}) → void
+  return (core::String s, {core::int i = #C2}) → void => self::I2|m(#this, s, i: i);
+static method main() → dynamic {
+  self::expect(42, self::I|(0));
+  self::expect(0, self::I|(0, 0));
+  self::expect(87, self::I2|(0));
+  self::expect(0, self::I2|(0, y: 0));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual)) {
+    throw "Expected ${expected}, actual ${actual}";
+  }
+}
+
+constants  {
+  #C1 = null
+  #C2 = 1
+}

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.textual_outline.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.textual_outline.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.textual_outline.expect
new file mode 100644
index 0000000..4397286
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.textual_outline.expect
@@ -0,0 +1,14 @@
+inline
+class I {
+  final int it;
+  I(int x, [int? y]) : it = x + (y ?? 42);
+  void m(String s, [int i = 1]) {}
+}
+inline
+class I2 {
+  final int it;
+  I2(int x, {int? y}) : it = x + (y ?? 87);
+  void m(String s, {int i = 1}) {}
+}
+main() {}
+expect(expected, actual) {}

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.expect
new file mode 100644
index 0000000..951d3d3
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.expect
@@ -0,0 +1,50 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+inline class I /* declaredRepresentationType = core::int */ {
+  method m = self::I|m;
+  tearoff m = self::I|get#m;
+  constructor • = self::I|;
+  tearoff • = self::I|get#;
+}
+inline class I2 /* declaredRepresentationType = core::int */ {
+  method m = self::I2|m;
+  tearoff m = self::I2|get#m;
+  constructor • = self::I2|;
+  tearoff • = self::I2|get#;
+}
+static method I|(core::int x, [core::int? y = #C1]) → self::I {
+  final self::I #this = x.{core::num::+}(let final core::int? #t1 = y in #t1 == null ?{core::int} 42 : #t1{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I|get#(core::int x, [core::int? y]) → self::I
+  return self::I|(x, y);
+static method I|m(lowered final self::I #this, core::String s, [core::int i = #C2]) → void {}
+static method I|get#m(lowered final self::I #this) → (core::String, [core::int]) → void
+  return (core::String s, [core::int i = #C2]) → void => self::I|m(#this, s, i);
+static method I2|(core::int x, {core::int? y = #C1}) → self::I2 {
+  final self::I2 #this = x.{core::num::+}(let final core::int? #t2 = y in #t2 == null ?{core::int} 87 : #t2{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I2|get#(core::int x, {core::int? y}) → self::I2
+  return self::I2|(x, y: y);
+static method I2|m(lowered final self::I2 #this, core::String s, {core::int i = #C2}) → void {}
+static method I2|get#m(lowered final self::I2 #this) → (core::String, {i: core::int}) → void
+  return (core::String s, {core::int i = #C2}) → void => self::I2|m(#this, s, i: i);
+static method main() → dynamic {
+  self::expect(42, self::I|(0));
+  self::expect(0, self::I|(0, 0));
+  self::expect(87, self::I2|(0));
+  self::expect(0, self::I2|(0, y: 0));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual)) {
+    throw "Expected ${expected}, actual ${actual}";
+  }
+}
+
+constants  {
+  #C1 = null
+  #C2 = 1
+}

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.modular.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.modular.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.modular.expect
new file mode 100644
index 0000000..951d3d3
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.modular.expect
@@ -0,0 +1,50 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+inline class I /* declaredRepresentationType = core::int */ {
+  method m = self::I|m;
+  tearoff m = self::I|get#m;
+  constructor • = self::I|;
+  tearoff • = self::I|get#;
+}
+inline class I2 /* declaredRepresentationType = core::int */ {
+  method m = self::I2|m;
+  tearoff m = self::I2|get#m;
+  constructor • = self::I2|;
+  tearoff • = self::I2|get#;
+}
+static method I|(core::int x, [core::int? y = #C1]) → self::I {
+  final self::I #this = x.{core::num::+}(let final core::int? #t1 = y in #t1 == null ?{core::int} 42 : #t1{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I|get#(core::int x, [core::int? y]) → self::I
+  return self::I|(x, y);
+static method I|m(lowered final self::I #this, core::String s, [core::int i = #C2]) → void {}
+static method I|get#m(lowered final self::I #this) → (core::String, [core::int]) → void
+  return (core::String s, [core::int i = #C2]) → void => self::I|m(#this, s, i);
+static method I2|(core::int x, {core::int? y = #C1}) → self::I2 {
+  final self::I2 #this = x.{core::num::+}(let final core::int? #t2 = y in #t2 == null ?{core::int} 87 : #t2{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I2|get#(core::int x, {core::int? y}) → self::I2
+  return self::I2|(x, y: y);
+static method I2|m(lowered final self::I2 #this, core::String s, {core::int i = #C2}) → void {}
+static method I2|get#m(lowered final self::I2 #this) → (core::String, {i: core::int}) → void
+  return (core::String s, {core::int i = #C2}) → void => self::I2|m(#this, s, i: i);
+static method main() → dynamic {
+  self::expect(42, self::I|(0));
+  self::expect(0, self::I|(0, 0));
+  self::expect(87, self::I2|(0));
+  self::expect(0, self::I2|(0, y: 0));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual)) {
+    throw "Expected ${expected}, actual ${actual}";
+  }
+}
+
+constants  {
+  #C1 = null
+  #C2 = 1
+}

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.outline.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.outline.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.outline.expect
new file mode 100644
index 0000000..c6eb0fe
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.outline.expect
@@ -0,0 +1,36 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+inline class I /* declaredRepresentationType = core::int */ {
+  method m = self::I|m;
+  tearoff m = self::I|get#m;
+  constructor • = self::I|;
+  tearoff • = self::I|get#;
+}
+inline class I2 /* declaredRepresentationType = core::int */ {
+  method m = self::I2|m;
+  tearoff m = self::I2|get#m;
+  constructor • = self::I2|;
+  tearoff • = self::I2|get#;
+}
+static method I|(core::int x, [core::int? y]) → self::I
+  ;
+static method I|get#(core::int x, [core::int? y]) → self::I
+  return self::I|(x, y);
+static method I|m(lowered final self::I #this, core::String s, [has-declared-initializer core::int i]) → void
+  ;
+static method I|get#m(lowered final self::I #this) → (core::String, [core::int]) → void
+  return (core::String s, [core::int i]) → void => self::I|m(#this, s, i);
+static method I2|(core::int x, {core::int? y}) → self::I2
+  ;
+static method I2|get#(core::int x, {core::int? y}) → self::I2
+  return self::I2|(x, y: y);
+static method I2|m(lowered final self::I2 #this, core::String s, {has-declared-initializer core::int i}) → void
+  ;
+static method I2|get#m(lowered final self::I2 #this) → (core::String, {i: core::int}) → void
+  return (core::String s, {core::int i}) → void => self::I2|m(#this, s, i: i);
+static method main() → dynamic
+  ;
+static method expect(dynamic expected, dynamic actual) → dynamic
+  ;

pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.transformed.expect

diff --git a/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.transformed.expect b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.transformed.expect
new file mode 100644
index 0000000..951d3d3
--- /dev/null
+++ b/pkg/front_end/testcases/inline_class/constructor_formal_parameters.dart.weak.transformed.expect
@@ -0,0 +1,50 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+inline class I /* declaredRepresentationType = core::int */ {
+  method m = self::I|m;
+  tearoff m = self::I|get#m;
+  constructor • = self::I|;
+  tearoff • = self::I|get#;
+}
+inline class I2 /* declaredRepresentationType = core::int */ {
+  method m = self::I2|m;
+  tearoff m = self::I2|get#m;
+  constructor • = self::I2|;
+  tearoff • = self::I2|get#;
+}
+static method I|(core::int x, [core::int? y = #C1]) → self::I {
+  final self::I #this = x.{core::num::+}(let final core::int? #t1 = y in #t1 == null ?{core::int} 42 : #t1{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I|get#(core::int x, [core::int? y]) → self::I
+  return self::I|(x, y);
+static method I|m(lowered final self::I #this, core::String s, [core::int i = #C2]) → void {}
+static method I|get#m(lowered final self::I #this) → (core::String, [core::int]) → void
+  return (core::String s, [core::int i = #C2]) → void => self::I|m(#this, s, i);
+static method I2|(core::int x, {core::int? y = #C1}) → self::I2 {
+  final self::I2 #this = x.{core::num::+}(let final core::int? #t2 = y in #t2 == null ?{core::int} 87 : #t2{core::int}){(core::num) → core::int};
+  return #this;
+}
+static method I2|get#(core::int x, {core::int? y}) → self::I2
+  return self::I2|(x, y: y);
+static method I2|m(lowered final self::I2 #this, core::String s, {core::int i = #C2}) → void {}
+static method I2|get#m(lowered final self::I2 #this) → (core::String, {i: core::int}) → void
+  return (core::String s, {core::int i = #C2}) → void => self::I2|m(#this, s, i: i);
+static method main() → dynamic {
+  self::expect(42, self::I|(0));
+  self::expect(0, self::I|(0, 0));
+  self::expect(87, self::I2|(0));
+  self::expect(0, self::I2|(0, y: 0));
+}
+static method expect(dynamic expected, dynamic actual) → dynamic {
+  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual)) {
+    throw "Expected ${expected}, actual ${actual}";
+  }
+}
+
+constants  {
+  #C1 = null
+  #C2 = 1
+}

pkg/front_end/testcases/patterns/const_patterns.dart

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart b/pkg/front_end/testcases/patterns/const_patterns.dart
new file mode 100644
index 0000000..b6ef3fa
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart
@@ -0,0 +1,93 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'const_patterns.dart' as prefix;
+
+const int value = 42;
+
+void func() {}
+
+class Class {
+  const Class([a]);
+
+  call() {}
+
+  test(o) async {
+    const dynamic local = 0;
+    dynamic variable = 0;
+    switch (o) {
+      case true: // Ok
+      case null: // Ok
+      case this: // Error
+      case this(): // Error
+      case super(): // Error
+      case 42: // Ok
+      case -42: // Ok
+      case 42.5: // Ok
+      case -42.5: // Ok
+      case 'foo': // Ok
+      case 'foo' 'bar': // Ok
+      case value: // Ok
+      case -value: // Error
+      case local: // Ok
+      case -local: // Error
+      case func: // Ok
+      case prefix.value: // Ok
+      case -prefix.value: // Error
+      case 1 + 2: // Error
+      case 1 * 2: // Error
+      case void fun() {}: // Error
+      case assert(false): // Error
+      case switch (o) { _ => true }: // Error
+      case await 0: // Error
+      case !false: // Error
+      case ~0: // Error
+      case ++variable: // Error
+      case const Class(): // Ok
+      case const Class(0): // Ok
+      case const GenericClass(): // Ok
+      case const GenericClass(a: 0): // Ok
+      case const GenericClass<int>(): // Ok
+      case const GenericClass<int>(a: 0): // Ok
+      case const GenericClass<int>.new(): // Ok
+      case const GenericClass<int>.new(a: 1): // Ok
+      case const []: // Ok
+      case const <int>[]: // Ok
+      case const {}: // Ok
+      case const <int, String>{}: // Ok
+      case const const Class(): // Error
+      case const const Class(0): // Error
+      case const const GenericClass(): // Error
+      case const const GenericClass(a: 0): // Error
+      case const const GenericClass<int>(): // Error
+      case const const GenericClass<int>(a: 0): // Error
+      case const const []: // Error
+      case const const <int>[]: // Error
+      case const const {}: // Error
+      case const const <int, String>{}: // Error
+      case const new Class(): // Error
+      case new Class(): // Error
+      case const (): // Error
+      case const const (): // Error
+      case const (1): // Ok
+      case const (-1): // Ok
+      case const (value): // Ok
+      case const (-value): // Ok
+      case const (1 + 2): // Ok
+      case GenericClass<int>: // Error
+      case prefix.GenericClass<int>: // Error
+      case GenericClass<int>.new: // Error
+      case prefix.GenericClass<int>.new: // Error
+      case const (GenericClass<int>): // Ok
+      case const (prefix.GenericClass<int>): // Ok
+      case const (GenericClass<int>.new): // Ok
+      case const (prefix.GenericClass<int>.new): // Ok
+       print(0);
+    }
+  }
+}
+
+class GenericClass<T> {
+  const GenericClass({a});
+}

pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect
new file mode 100644
index 0000000..e05d5bb
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.expect
@@ -0,0 +1,337 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+//       case super(): // Error
+//            ^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:32:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -value: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:34:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -local: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:37:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -prefix.value: // Error
+//             ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: Expected ':' before this.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: '+' is not a prefix operator.
+// Try removing '+'.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:16: Error: Expected ';' after this.
+//       case 1 + 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Unexpected token ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected ':' before this.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected an identifier, but got '*'.
+// Try inserting an identifier before '*'.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:16: Error: Expected ';' after this.
+//       case 1 * 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Unexpected token ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:20: Error: Expected ':' before this.
+//       case void fun() {}: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:24: Error: Expected ';' after this.
+//       case void fun() {}: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Unexpected token ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+//       case assert(false): // Error
+//            ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:20: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:44:12: Error: The unary operator ! is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case !false: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:45:12: Error: The unary operator ~ is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case ~0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+//       case ++variable: // Error
+//              ^^^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:59:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:60:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:61:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:62:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:63:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:64:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:65:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const []: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:66:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int>[]: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:67:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const {}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:68:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int, String>{}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:18: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                  ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:12: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//            ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:71:19: Error: The empty record literal is not supported as a constant pattern.
+//       case const (): // Error
+//                   ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:72:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const (): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:78:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:79:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:80:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>.new: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:81:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>.new: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:22:12: Error: Not a constant expression.
+//       case this: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:23:12: Error: Not a constant expression.
+//       case this(): // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:12: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:43:12: Error: Not a constant expression.
+//       case await 0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:22: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                      ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:16: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//                ^
+//
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_patterns.dart" as prefix;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •([dynamic a = #C1]) → self::Class
+    : super core::Object::•()
+    ;
+  method call() → dynamic {}
+  method test(dynamic o) → dynamic async /* futureValueType= dynamic */ {
+    dynamic variable = 0;
+    #L1:
+    {
+      void fun;
+      final dynamic #1#0 = o;
+      final const self::Class #1#5 = invalid-expression "Not a constant expression.";
+      final const dynamic #1#7 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#9 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^";
+      final const invalid-type #1#41 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^";
+      final const core::bool #1#43 = invalid-expression "Not a constant expression.";
+      final const core::int #1#45 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#51 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^";
+      final const self::Class #1#97 = invalid-expression "New expression is not a constant expression.";
+      final const self::Class #1#99 = invalid-expression "New expression is not a constant expression.";
+      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #1#0 == null || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C6 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C7 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C8 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C10 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+        {
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+             ^"{<invalid>}.+(2);
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+                ^";
+          break #L1;
+        }
+      }
+      else
+        if(#C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+          {
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+             ^"{<invalid>}.*(2);
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+                ^";
+            break #L1;
+          }
+        }
+        else
+          if(#1#0 is{ForNonNullableByDefault} void && (let final dynamic #t1 = fun = #1#0{void} in true)) {
+            {
+              () → Never {};
+              invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: This couldn't be parsed.
+      case void fun() {}: // Error
+                        ^";
+              break #L1;
+            }
+          }
+          else
+            if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #1#0 || #C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C21 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+              {
+                core::print(0);
+              }
+            }
+    }
+  }
+}
+class GenericClass<T extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  const constructor •({dynamic a = #C1}) → self::GenericClass<self::GenericClass::T%>
+    : super core::Object::•()
+    ;
+}
+static const field core::int value = #C3;
+static method func() → void {}
+
+constants  {
+  #C1 = null
+  #C2 = true
+  #C3 = 42
+  #C4 = -42
+  #C5 = 42.5
+  #C6 = -42.5
+  #C7 = "foo"
+  #C8 = "foobar"
+  #C9 = 0
+  #C10 = static-tearoff self::func
+  #C11 = 1
+  #C12 = -1
+  #C13 = self::Class {}
+  #C14 = self::GenericClass<dynamic> {}
+  #C15 = self::GenericClass<core::int> {}
+  #C16 = <dynamic>[]
+  #C17 = <core::int>[]
+  #C18 = <dynamic, dynamic>{)
+  #C19 = <core::int, core::String>{)
+  #C20 = ()
+  #C21 = 3
+  #C22 = TypeLiteralConstant(self::GenericClass<core::int>)
+  #C23 = constructor-tearoff self::GenericClass::•
+  #C24 = instantiation #C23 <core::int>
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///const_patterns.dart:
+- Class. (from org-dartlang-testcase:///const_patterns.dart:12:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- GenericClass. (from org-dartlang-testcase:///const_patterns.dart:92:9)

pkg/front_end/testcases/patterns/const_patterns.dart.strong.transformed.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.strong.transformed.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.transformed.expect
new file mode 100644
index 0000000..59ad3a8
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.strong.transformed.expect
@@ -0,0 +1,337 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+//       case super(): // Error
+//            ^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:32:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -value: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:34:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -local: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:37:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -prefix.value: // Error
+//             ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: Expected ':' before this.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: '+' is not a prefix operator.
+// Try removing '+'.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:16: Error: Expected ';' after this.
+//       case 1 + 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Unexpected token ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected ':' before this.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected an identifier, but got '*'.
+// Try inserting an identifier before '*'.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:16: Error: Expected ';' after this.
+//       case 1 * 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Unexpected token ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:20: Error: Expected ':' before this.
+//       case void fun() {}: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:24: Error: Expected ';' after this.
+//       case void fun() {}: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Unexpected token ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+//       case assert(false): // Error
+//            ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:20: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:44:12: Error: The unary operator ! is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case !false: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:45:12: Error: The unary operator ~ is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case ~0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+//       case ++variable: // Error
+//              ^^^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:59:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:60:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:61:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:62:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:63:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:64:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:65:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const []: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:66:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int>[]: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:67:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const {}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:68:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int, String>{}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:18: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                  ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:12: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//            ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:71:19: Error: The empty record literal is not supported as a constant pattern.
+//       case const (): // Error
+//                   ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:72:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const (): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:78:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:79:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:80:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>.new: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:81:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>.new: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:22:12: Error: Not a constant expression.
+//       case this: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:23:12: Error: Not a constant expression.
+//       case this(): // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:12: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:43:12: Error: Not a constant expression.
+//       case await 0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:22: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                      ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:16: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//                ^
+//
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_patterns.dart" as prefix;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •([dynamic a = #C1]) → self::Class
+    : super core::Object::•()
+    ;
+  method call() → dynamic {}
+  method test(dynamic o) → dynamic async /* futureValueType= dynamic */ {
+    dynamic variable = 0;
+    #L1:
+    {
+      void fun;
+      final dynamic #1#0 = o;
+      final const self::Class #1#5 = invalid-expression "Not a constant expression.";
+      final const dynamic #1#7 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#9 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^";
+      final const invalid-type #1#41 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^";
+      final const core::bool #1#43 = invalid-expression "Not a constant expression.";
+      final const core::int #1#45 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#51 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^";
+      final const self::Class #1#97 = invalid-expression "New expression is not a constant expression.";
+      final const self::Class #1#99 = invalid-expression "New expression is not a constant expression.";
+      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #1#0 == null || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C6 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C7 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C8 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C10 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+        {
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+             ^"{<invalid>}.+(2);
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+                ^";
+          break #L1;
+        }
+      }
+      else
+        if(#C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+          {
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+             ^"{<invalid>}.*(2);
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+                ^";
+            break #L1;
+          }
+        }
+        else
+          if(#1#0 is{ForNonNullableByDefault} void && (let final void #t1 = fun = #1#0{void} in true)) {
+            {
+              () → Never {};
+              invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: This couldn't be parsed.
+      case void fun() {}: // Error
+                        ^";
+              break #L1;
+            }
+          }
+          else
+            if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #1#0 || #C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C21 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+              {
+                core::print(0);
+              }
+            }
+    }
+  }
+}
+class GenericClass<T extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  const constructor •({dynamic a = #C1}) → self::GenericClass<self::GenericClass::T%>
+    : super core::Object::•()
+    ;
+}
+static const field core::int value = #C3;
+static method func() → void {}
+
+constants  {
+  #C1 = null
+  #C2 = true
+  #C3 = 42
+  #C4 = -42
+  #C5 = 42.5
+  #C6 = -42.5
+  #C7 = "foo"
+  #C8 = "foobar"
+  #C9 = 0
+  #C10 = static-tearoff self::func
+  #C11 = 1
+  #C12 = -1
+  #C13 = self::Class {}
+  #C14 = self::GenericClass<dynamic> {}
+  #C15 = self::GenericClass<core::int> {}
+  #C16 = <dynamic>[]
+  #C17 = <core::int>[]
+  #C18 = <dynamic, dynamic>{)
+  #C19 = <core::int, core::String>{)
+  #C20 = ()
+  #C21 = 3
+  #C22 = TypeLiteralConstant(self::GenericClass<core::int>)
+  #C23 = constructor-tearoff self::GenericClass::•
+  #C24 = instantiation #C23 <core::int>
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///const_patterns.dart:
+- Class. (from org-dartlang-testcase:///const_patterns.dart:12:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- GenericClass. (from org-dartlang-testcase:///const_patterns.dart:92:9)

pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline.expect
new file mode 100644
index 0000000..e40a7f3
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline.expect
@@ -0,0 +1,14 @@
+import 'const_patterns.dart' as prefix;
+
+const int value = 42;
+void func() {}
+
+class Class {
+  const Class([a]);
+  call() {}
+  test(o) async {}
+}
+
+class GenericClass<T> {
+  const GenericClass({a});
+}

pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline_modelled.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..6c3150c
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.textual_outline_modelled.expect
@@ -0,0 +1,14 @@
+import 'const_patterns.dart' as prefix;
+
+class Class {
+  call() {}
+  const Class([a]);
+  test(o) async {}
+}
+
+class GenericClass<T> {
+  const GenericClass({a});
+}
+
+const int value = 42;
+void func() {}

pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect
new file mode 100644
index 0000000..66bbfe1
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.expect
@@ -0,0 +1,337 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+//       case super(): // Error
+//            ^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:32:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -value: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:34:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -local: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:37:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -prefix.value: // Error
+//             ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: Expected ':' before this.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: '+' is not a prefix operator.
+// Try removing '+'.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:16: Error: Expected ';' after this.
+//       case 1 + 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Unexpected token ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected ':' before this.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected an identifier, but got '*'.
+// Try inserting an identifier before '*'.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:16: Error: Expected ';' after this.
+//       case 1 * 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Unexpected token ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:20: Error: Expected ':' before this.
+//       case void fun() {}: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:24: Error: Expected ';' after this.
+//       case void fun() {}: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Unexpected token ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+//       case assert(false): // Error
+//            ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:20: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:44:12: Error: The unary operator ! is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case !false: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:45:12: Error: The unary operator ~ is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case ~0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+//       case ++variable: // Error
+//              ^^^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:59:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:60:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:61:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:62:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:63:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:64:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:65:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const []: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:66:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int>[]: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:67:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const {}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:68:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int, String>{}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:18: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                  ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:12: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//            ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:71:19: Error: The empty record literal is not supported as a constant pattern.
+//       case const (): // Error
+//                   ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:72:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const (): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:78:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:79:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:80:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>.new: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:81:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>.new: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:22:12: Error: Not a constant expression.
+//       case this: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:23:12: Error: Not a constant expression.
+//       case this(): // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:12: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:43:12: Error: Not a constant expression.
+//       case await 0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:22: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                      ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:16: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//                ^
+//
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_patterns.dart" as prefix;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •([dynamic a = #C1]) → self::Class
+    : super core::Object::•()
+    ;
+  method call() → dynamic {}
+  method test(dynamic o) → dynamic async /* futureValueType= dynamic */ {
+    dynamic variable = 0;
+    #L1:
+    {
+      void fun;
+      final dynamic #1#0 = o;
+      final const self::Class #1#5 = invalid-expression "Not a constant expression.";
+      final const dynamic #1#7 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#9 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^";
+      final const invalid-type #1#41 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^";
+      final const core::bool #1#43 = invalid-expression "Not a constant expression.";
+      final const core::int #1#45 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#51 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^";
+      final const self::Class #1#97 = invalid-expression "New expression is not a constant expression.";
+      final const self::Class #1#99 = invalid-expression "New expression is not a constant expression.";
+      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #1#0 == null || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C6 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C7 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C8 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C10 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+        {
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+             ^"{<invalid>}.+(2);
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+                ^";
+          break #L1;
+        }
+      }
+      else
+        if(#C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+          {
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+             ^"{<invalid>}.*(2);
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+                ^";
+            break #L1;
+          }
+        }
+        else
+          if(#1#0 is{ForNonNullableByDefault} void && (let final dynamic #t1 = fun = #1#0{void} in true)) {
+            {
+              () → Never {};
+              invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: This couldn't be parsed.
+      case void fun() {}: // Error
+                        ^";
+              break #L1;
+            }
+          }
+          else
+            if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #1#0 || #C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C21 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+              {
+                core::print(0);
+              }
+            }
+    }
+  }
+}
+class GenericClass<T extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  const constructor •({dynamic a = #C1}) → self::GenericClass<self::GenericClass::T%>
+    : super core::Object::•()
+    ;
+}
+static const field core::int value = #C3;
+static method func() → void {}
+
+constants  {
+  #C1 = null
+  #C2 = true
+  #C3 = 42
+  #C4 = -42
+  #C5 = 42.5
+  #C6 = -42.5
+  #C7 = "foo"
+  #C8 = "foobar"
+  #C9 = 0
+  #C10 = static-tearoff self::func
+  #C11 = 1
+  #C12 = -1
+  #C13 = self::Class {}
+  #C14 = self::GenericClass<dynamic> {}
+  #C15 = self::GenericClass<core::int*> {}
+  #C16 = <dynamic>[]
+  #C17 = <core::int*>[]
+  #C18 = <dynamic, dynamic>{)
+  #C19 = <core::int*, core::String*>{)
+  #C20 = ()
+  #C21 = 3
+  #C22 = TypeLiteralConstant(self::GenericClass<core::int*>*)
+  #C23 = constructor-tearoff self::GenericClass::•
+  #C24 = instantiation #C23 <core::int*>
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///const_patterns.dart:
+- Class. (from org-dartlang-testcase:///const_patterns.dart:12:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- GenericClass. (from org-dartlang-testcase:///const_patterns.dart:92:9)

pkg/front_end/testcases/patterns/const_patterns.dart.weak.modular.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.modular.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.modular.expect
new file mode 100644
index 0000000..66bbfe1
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.modular.expect
@@ -0,0 +1,337 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+//       case super(): // Error
+//            ^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:32:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -value: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:34:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -local: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:37:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -prefix.value: // Error
+//             ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: Expected ':' before this.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: '+' is not a prefix operator.
+// Try removing '+'.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:16: Error: Expected ';' after this.
+//       case 1 + 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Unexpected token ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected ':' before this.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected an identifier, but got '*'.
+// Try inserting an identifier before '*'.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:16: Error: Expected ';' after this.
+//       case 1 * 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Unexpected token ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:20: Error: Expected ':' before this.
+//       case void fun() {}: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:24: Error: Expected ';' after this.
+//       case void fun() {}: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Unexpected token ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+//       case assert(false): // Error
+//            ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:20: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:44:12: Error: The unary operator ! is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case !false: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:45:12: Error: The unary operator ~ is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case ~0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+//       case ++variable: // Error
+//              ^^^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:59:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:60:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:61:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:62:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:63:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:64:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:65:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const []: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:66:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int>[]: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:67:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const {}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:68:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int, String>{}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:18: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                  ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:12: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//            ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:71:19: Error: The empty record literal is not supported as a constant pattern.
+//       case const (): // Error
+//                   ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:72:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const (): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:78:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:79:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:80:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>.new: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:81:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>.new: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:22:12: Error: Not a constant expression.
+//       case this: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:23:12: Error: Not a constant expression.
+//       case this(): // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:12: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:43:12: Error: Not a constant expression.
+//       case await 0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:22: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                      ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:16: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//                ^
+//
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_patterns.dart" as prefix;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •([dynamic a = #C1]) → self::Class
+    : super core::Object::•()
+    ;
+  method call() → dynamic {}
+  method test(dynamic o) → dynamic async /* futureValueType= dynamic */ {
+    dynamic variable = 0;
+    #L1:
+    {
+      void fun;
+      final dynamic #1#0 = o;
+      final const self::Class #1#5 = invalid-expression "Not a constant expression.";
+      final const dynamic #1#7 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#9 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^";
+      final const invalid-type #1#41 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^";
+      final const core::bool #1#43 = invalid-expression "Not a constant expression.";
+      final const core::int #1#45 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#51 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^";
+      final const self::Class #1#97 = invalid-expression "New expression is not a constant expression.";
+      final const self::Class #1#99 = invalid-expression "New expression is not a constant expression.";
+      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #1#0 == null || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C6 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C7 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C8 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C10 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+        {
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+             ^"{<invalid>}.+(2);
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+                ^";
+          break #L1;
+        }
+      }
+      else
+        if(#C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+          {
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+             ^"{<invalid>}.*(2);
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+                ^";
+            break #L1;
+          }
+        }
+        else
+          if(#1#0 is{ForNonNullableByDefault} void && (let final dynamic #t1 = fun = #1#0{void} in true)) {
+            {
+              () → Never {};
+              invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: This couldn't be parsed.
+      case void fun() {}: // Error
+                        ^";
+              break #L1;
+            }
+          }
+          else
+            if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #1#0 || #C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C21 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+              {
+                core::print(0);
+              }
+            }
+    }
+  }
+}
+class GenericClass<T extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  const constructor •({dynamic a = #C1}) → self::GenericClass<self::GenericClass::T%>
+    : super core::Object::•()
+    ;
+}
+static const field core::int value = #C3;
+static method func() → void {}
+
+constants  {
+  #C1 = null
+  #C2 = true
+  #C3 = 42
+  #C4 = -42
+  #C5 = 42.5
+  #C6 = -42.5
+  #C7 = "foo"
+  #C8 = "foobar"
+  #C9 = 0
+  #C10 = static-tearoff self::func
+  #C11 = 1
+  #C12 = -1
+  #C13 = self::Class {}
+  #C14 = self::GenericClass<dynamic> {}
+  #C15 = self::GenericClass<core::int*> {}
+  #C16 = <dynamic>[]
+  #C17 = <core::int*>[]
+  #C18 = <dynamic, dynamic>{)
+  #C19 = <core::int*, core::String*>{)
+  #C20 = ()
+  #C21 = 3
+  #C22 = TypeLiteralConstant(self::GenericClass<core::int*>*)
+  #C23 = constructor-tearoff self::GenericClass::•
+  #C24 = instantiation #C23 <core::int*>
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///const_patterns.dart:
+- Class. (from org-dartlang-testcase:///const_patterns.dart:12:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- GenericClass. (from org-dartlang-testcase:///const_patterns.dart:92:9)

pkg/front_end/testcases/patterns/const_patterns.dart.weak.outline.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.outline.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.outline.expect
new file mode 100644
index 0000000..8583943
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.outline.expect
@@ -0,0 +1,23 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_patterns.dart" as prefix;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •([dynamic a = null]) → self::Class
+    : super core::Object::•()
+    ;
+  method call() → dynamic
+    ;
+  method test(dynamic o) → dynamic async 
+    ;
+}
+class GenericClass<T extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  const constructor •({dynamic a = null}) → self::GenericClass<self::GenericClass::T%>
+    : super core::Object::•()
+    ;
+}
+static const field core::int value = 42;
+static method func() → void
+  ;

pkg/front_end/testcases/patterns/const_patterns.dart.weak.transformed.expect

diff --git a/pkg/front_end/testcases/patterns/const_patterns.dart.weak.transformed.expect b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.transformed.expect
new file mode 100644
index 0000000..6574284
--- /dev/null
+++ b/pkg/front_end/testcases/patterns/const_patterns.dart.weak.transformed.expect
@@ -0,0 +1,337 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+//       case super(): // Error
+//            ^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:32:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -value: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:34:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -local: // Error
+//             ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:37:13: Error: Only negation of a numeric literal is supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case -prefix.value: // Error
+//             ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: Expected ':' before this.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: '+' is not a prefix operator.
+// Try removing '+'.
+//       case 1 + 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:16: Error: Expected ';' after this.
+//       case 1 + 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: Unexpected token ':'.
+//       case 1 + 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected ':' before this.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: Expected an identifier, but got '*'.
+// Try inserting an identifier before '*'.
+//       case 1 * 2: // Error
+//              ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:16: Error: Expected ';' after this.
+//       case 1 * 2: // Error
+//                ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: Unexpected token ':'.
+//       case 1 * 2: // Error
+//                 ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:20: Error: Expected ':' before this.
+//       case void fun() {}: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:24: Error: Expected ';' after this.
+//       case void fun() {}: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Expected an identifier, but got ':'.
+// Try inserting an identifier before ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: Unexpected token ':'.
+//       case void fun() {}: // Error
+//                         ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+//       case assert(false): // Error
+//            ^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:20: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//                    ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:44:12: Error: The unary operator ! is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case !false: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:45:12: Error: The unary operator ~ is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case ~0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+//       case ++variable: // Error
+//              ^^^^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:59:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:60:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const Class(0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:61:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:62:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:63:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:64:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const GenericClass<int>(a: 0): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:65:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const []: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:66:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int>[]: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:67:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const {}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:68:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const <int, String>{}: // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:18: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                  ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:12: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//            ^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:71:19: Error: The empty record literal is not supported as a constant pattern.
+//       case const (): // Error
+//                   ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:72:18: Error: Duplicate 'const' keyword in constant expression.
+// Try removing one of the 'const' keywords.
+//       case const const (): // Error
+//                  ^^^^^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:78:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:79:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:80:24: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case GenericClass<int>.new: // Error
+//                        ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:81:31: Error: This expression is not supported as a constant pattern.
+// Try wrapping the expression in 'const ( ... )'.
+//       case prefix.GenericClass<int>.new: // Error
+//                               ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:22:12: Error: Not a constant expression.
+//       case this: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:23:12: Error: Not a constant expression.
+//       case this(): // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:42:12: Error: Not a constant expression.
+//       case switch (o) { _ => true }: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:43:12: Error: Not a constant expression.
+//       case await 0: // Error
+//            ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:69:22: Error: New expression is not a constant expression.
+//       case const new Class(): // Error
+//                      ^
+//
+// pkg/front_end/testcases/patterns/const_patterns.dart:70:16: Error: New expression is not a constant expression.
+//       case new Class(): // Error
+//                ^
+//
+import self as self;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///const_patterns.dart" as prefix;
+
+class Class extends core::Object /*hasConstConstructor*/  {
+  const constructor •([dynamic a = #C1]) → self::Class
+    : super core::Object::•()
+    ;
+  method call() → dynamic {}
+  method test(dynamic o) → dynamic async /* futureValueType= dynamic */ {
+    dynamic variable = 0;
+    #L1:
+    {
+      void fun;
+      final dynamic #1#0 = o;
+      final const self::Class #1#5 = invalid-expression "Not a constant expression.";
+      final const dynamic #1#7 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#9 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^";
+      final const invalid-type #1#41 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^";
+      final const core::bool #1#43 = invalid-expression "Not a constant expression.";
+      final const core::int #1#45 = invalid-expression "Not a constant expression.";
+      final const invalid-type #1#51 = invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^";
+      final const self::Class #1#97 = invalid-expression "New expression is not a constant expression.";
+      final const self::Class #1#99 = invalid-expression "New expression is not a constant expression.";
+      if(#C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #1#0 == null || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:24:12: Error: Method invocation is not a constant expression.
+      case super(): // Error
+           ^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C5 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C6 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C7 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C8 =={core::String::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C9 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C10 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+        {
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:14: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+             ^"{<invalid>}.+(2);
+          invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:38:17: Error: This couldn't be parsed.
+      case 1 + 2: // Error
+                ^";
+          break #L1;
+        }
+      }
+      else
+        if(#C11 =={core::num::==}{(core::Object) → core::bool} #1#0) {
+          {
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:14: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+             ^"{<invalid>}.*(2);
+            invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:39:17: Error: This couldn't be parsed.
+      case 1 * 2: // Error
+                ^";
+            break #L1;
+          }
+        }
+        else
+          if(#1#0 is{ForNonNullableByDefault} void && (let final void #t1 = fun = #1#0{void} in true)) {
+            {
+              () → Never {};
+              invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:40:25: Error: This couldn't be parsed.
+      case void fun() {}: // Error
+                        ^";
+              break #L1;
+            }
+          }
+          else
+            if(invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:41:12: Error: `assert` can't be used as an expression.
+      case assert(false): // Error
+           ^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "Not a constant expression." =={core::num::==}{(core::Object) → core::bool} #1#0 || #C2 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || invalid-expression "pkg/front_end/testcases/patterns/const_patterns.dart:46:14: Error: Not a constant expression.
+      case ++variable: // Error
+             ^^^^^^^^" =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C13 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C14 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C15 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C16 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C17 =={core::List::==}{(core::Object) → core::bool} #1#0 || #C18 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C19 =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || invalid-expression "New expression is not a constant expression." =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C20 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C11 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C12 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C3 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C4 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C21 =={core::num::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C22 =={core::Type::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0 || #C24 =={core::Object::==}{(core::Object) → core::bool} #1#0) {
+              {
+                core::print(0);
+              }
+            }
+    }
+  }
+}
+class GenericClass<T extends core::Object? = dynamic> extends core::Object /*hasConstConstructor*/  {
+  const constructor •({dynamic a = #C1}) → self::GenericClass<self::GenericClass::T%>
+    : super core::Object::•()
+    ;
+}
+static const field core::int value = #C3;
+static method func() → void {}
+
+constants  {
+  #C1 = null
+  #C2 = true
+  #C3 = 42
+  #C4 = -42
+  #C5 = 42.5
+  #C6 = -42.5
+  #C7 = "foo"
+  #C8 = "foobar"
+  #C9 = 0
+  #C10 = static-tearoff self::func
+  #C11 = 1
+  #C12 = -1
+  #C13 = self::Class {}
+  #C14 = self::GenericClass<dynamic> {}
+  #C15 = self::GenericClass<core::int*> {}
+  #C16 = <dynamic>[]
+  #C17 = <core::int*>[]
+  #C18 = <dynamic, dynamic>{)
+  #C19 = <core::int*, core::String*>{)
+  #C20 = ()
+  #C21 = 3
+  #C22 = TypeLiteralConstant(self::GenericClass<core::int*>*)
+  #C23 = constructor-tearoff self::GenericClass::•
+  #C24 = instantiation #C23 <core::int*>
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///const_patterns.dart:
+- Class. (from org-dartlang-testcase:///const_patterns.dart:12:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- GenericClass. (from org-dartlang-testcase:///const_patterns.dart:92:9)

pkg/front_end/testcases/textual_outline.status

diff --git a/pkg/front_end/testcases/textual_outline.status b/pkg/front_end/testcases/textual_outline.status
index 10c706a..1ab8295 100644
--- a/pkg/front_end/testcases/textual_outline.status
+++ b/pkg/front_end/testcases/textual_outline.status
@@ -129,6 +129,7 @@
 general/var_as_type_name: FormatterCrash
 inline_class/constructor_access: FormatterCrash
 inline_class/constructor_bodies: FormatterCrash
+inline_class/constructor_formal_parameters: FormatterCrash
 inline_class/constructors: FormatterCrash
 inline_class/external: FormatterCrash
 inline_class/field_access: FormatterCrash

sdk/lib/_internal/wasm/lib/sync_star_patch.dart

diff --git a/sdk/lib/_internal/wasm/lib/sync_star_patch.dart b/sdk/lib/_internal/wasm/lib/sync_star_patch.dart
new file mode 100644
index 0000000..e6f0ad3
--- /dev/null
+++ b/sdk/lib/_internal/wasm/lib/sync_star_patch.dart
@@ -0,0 +1,160 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:wasm';
+
+// Signature of the inner function of a `sync*` function. It takes the state
+// object and a pending exception to be thrown (only for `yield*`).
+// The function returns `true` if it is suspended by a `yield` or `yield*`, or
+// `false` if it reaches the end of the function or a `return` statement.
+typedef _ResumeFun
+    = WasmFunction<bool Function(_SuspendState, Object?, StackTrace?)>;
+
+// The CFG target index of the entry point to the `sync*` body.
+const int _initialTargetIndex = 0;
+
+// The execution state of a `sync*` function body.
+@pragma("wasm:entry-point")
+class _SuspendState {
+  // The inner function.
+  final _ResumeFun _resume;
+  // Parent state to transition to when this body completes. This will be
+  // present when the `sync*` iterable was consumed by a `yield*`.
+  final _SuspendState? _parent;
+
+  // The iterator that this state belongs to. All states in the parent chain
+  // belong to the same iterator.
+  @pragma("wasm:entry-point")
+  _SyncStarIterator? _iterator;
+  // Context containing the local variables of the function.
+  @pragma("wasm:entry-point")
+  WasmStructRef? _context;
+  // CFG target index for the next resumption.
+  @pragma("wasm:entry-point")
+  WasmI32 _targetIndex;
+
+  _SuspendState(_SyncStarIterable iterable, _SuspendState? parent)
+      : _resume = iterable._resume,
+        _parent = parent,
+        _context = iterable._context,
+        _targetIndex = WasmI32.fromInt(_initialTargetIndex);
+}
+
+/// An [Iterable] returned from a `sync*` function.
+@pragma("wasm:entry-point")
+class _SyncStarIterable<T> extends Iterable<T> {
+  // Context capturing the arguments to the `sync*` function and/or further
+  // context when the `sync*` function is a lambda.
+  @pragma("wasm:entry-point")
+  WasmStructRef? _context;
+  // The inner function.
+  @pragma("wasm:entry-point")
+  _ResumeFun _resume;
+
+  external _SyncStarIterable();
+
+  @pragma("wasm:entry-point")
+  Iterator<T> get iterator {
+    return _SyncStarIterator<T>(this);
+  }
+}
+
+/// An [Iterator] for a `sync*` function.
+@pragma("wasm:entry-point")
+class _SyncStarIterator<T> implements Iterator<T> {
+  // The resume function sets either [_current] (for `yield`) or
+  // [_yieldStarIterable] (for `yield*`).
+  @pragma("wasm:entry-point")
+  T? _current;
+  @pragma("wasm:entry-point")
+  Iterable<T>? _yieldStarIterable;
+
+  // Current iterator for a `yield*` if the iterable given to the `yield*` is
+  // not a `_YieldStarIterable`.
+  Iterator<T>? _yieldStarIterator;
+
+  // Current state.
+  _SuspendState _state;
+
+  @override
+  T get current => _current as T;
+
+  _SyncStarIterator(_SyncStarIterable iterable)
+      : _state = _SuspendState(iterable, null) {
+    _state._iterator = this;
+  }
+
+  @pragma('wasm:prefer-inline')
+  bool _handleSyncStarMethodCompletion() {
+    if (_state._parent != null) {
+      _state = _state._parent!;
+      return true;
+    }
+    _current = null;
+    return false;
+  }
+
+  @override
+  bool moveNext() {
+    Object? pendingException;
+    StackTrace? pendingStackTrace;
+    while (true) {
+      // First delegate to an active nested iterator (if any).
+      final iterator = _yieldStarIterator;
+      if (iterator != null) {
+        try {
+          if (iterator.moveNext()) {
+            _current = iterator.current;
+            return true;
+          }
+        } catch (exception, stackTrace) {
+          pendingException = exception;
+          pendingStackTrace = stackTrace;
+        }
+        _yieldStarIterator = null;
+      }
+
+      try {
+        // Resume current sync* method in order to move to the next value.
+        final bool hasMore =
+            _state._resume.call(_state, pendingException, pendingStackTrace);
+        pendingException = null;
+        pendingStackTrace = null;
+        if (!hasMore) {
+          if (_handleSyncStarMethodCompletion()) {
+            continue;
+          }
+          return false;
+        }
+      } catch (exception, stackTrace) {
+        pendingException = exception;
+        pendingStackTrace = stackTrace;
+        if (_handleSyncStarMethodCompletion()) {
+          continue;
+        }
+        rethrow;
+      }
+
+      // Case: yield* some_iterator.
+      final iterable = _yieldStarIterable;
+      if (iterable != null) {
+        if (iterable is _SyncStarIterable<T>) {
+          // We got a recursive yield* of sync* function. Instead of creating
+          // a new iterator we replace our current _state (remembering the
+          // current _state for later resumption).
+          _state = _SuspendState(iterable, _state).._iterator = this;
+        } else {
+          _yieldStarIterator = iterable.iterator;
+        }
+        _yieldStarIterable = null;
+        _current = null;
+        // Fetch the next item.
+        continue;
+      }
+
+      // Inner function has set [_current].
+      return true;
+    }
+  }
+}

sdk/lib/libraries.json

diff --git a/sdk/lib/libraries.json b/sdk/lib/libraries.json
index 3829332..52076ba 100644
--- a/sdk/lib/libraries.json
+++ b/sdk/lib/libraries.json
@@ -178,6 +178,7 @@
           "_internal/vm_shared/lib/string_buffer_patch.dart",
           "_internal/wasm/lib/date_patch_patch.dart",
           "_internal/wasm/lib/string_buffer_create.dart",
+          "_internal/wasm/lib/sync_star_patch.dart",
           "_internal/wasm/lib/weak_patch.dart"
         ]
       },

sdk/lib/libraries.yaml

diff --git a/sdk/lib/libraries.yaml b/sdk/lib/libraries.yaml
index 1f89f21..e77eb07 100644
--- a/sdk/lib/libraries.yaml
+++ b/sdk/lib/libraries.yaml
@@ -158,6 +158,7 @@
       - _internal/vm_shared/lib/string_buffer_patch.dart
       - _internal/wasm/lib/date_patch_patch.dart
       - _internal/wasm/lib/string_buffer_create.dart
+      - _internal/wasm/lib/sync_star_patch.dart
       - _internal/wasm/lib/weak_patch.dart
     developer:
       uri: developer/developer.dart

tests/language/patterns/invalid_const_pattern_test.dart

diff --git a/tests/language/patterns/invalid_const_pattern_test.dart b/tests/language/patterns/invalid_const_pattern_test.dart
new file mode 100644
index 0000000..aa0a8cd
--- /dev/null
+++ b/tests/language/patterns/invalid_const_pattern_test.dart
@@ -0,0 +1,234 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// SharedOptions=--enable-experiment=records,patterns
+
+import 'invalid_const_pattern_test.dart' as prefix;
+
+const int value = 42;
+
+void func() {}
+
+class Class {
+  const Class([a]);
+
+  call() {}
+
+  test(o) async {
+    const dynamic local = 0;
+    dynamic variable = 0;
+    switch (o) {
+      case true: // Ok
+      case null: // Ok
+      case this: // Error
+      //   ^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] Not a constant expression.
+      case this(): // Error
+      //   ^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] Not a constant expression.
+      case super(): // Error
+      //   ^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.INVOCATION_OF_NON_FUNCTION_EXPRESSION
+      //   ^^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] Method invocation is not a constant expression.
+      case 42: // Ok
+      case -42: // Ok
+      case 42.5: // Ok
+      case -42.5: // Ok
+      case 'foo': // Ok
+      case 'foo' 'bar': // Ok
+      case value: // Ok
+      case -value: // Error
+      //    ^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_NEGATION
+      // [cfe] Only negation of a numeric literal is supported as a constant pattern.
+      case local: // Ok
+      case -local: // Error
+      //    ^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_NEGATION
+      // [cfe] Only negation of a numeric literal is supported as a constant pattern.
+      case func: // Ok
+      case prefix.value: // Ok
+      case -prefix.value: // Error
+      //    ^^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_NEGATION
+      // [cfe] Only negation of a numeric literal is supported as a constant pattern.
+      case 1 + 2: // Error
+      //     ^
+      // [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN
+      // [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER
+      // [cfe] '+' is not a prefix operator.
+      // [cfe] Expected ':' before this.
+      //       ^
+      // [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN
+      // [cfe] Expected ';' after this.
+      //        ^
+      // [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER
+      // [analyzer] SYNTACTIC_ERROR.UNEXPECTED_TOKEN
+      // [cfe] Expected an identifier, but got ':'.
+      // [cfe] Unexpected token ':'.
+      case 1 * 2: // Error
+      //     ^
+      // [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN
+      // [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER
+      // [cfe] Expected ':' before this.
+      // [cfe] Expected an identifier, but got '*'.
+      //       ^
+      // [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN
+      // [cfe] Expected ';' after this.
+      //        ^
+      // [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER
+      // [analyzer] SYNTACTIC_ERROR.UNEXPECTED_TOKEN
+      // [cfe] Expected an identifier, but got ':'.
+      // [cfe] Unexpected token ':'.
+      case void fun() {}: // Error
+      //           ^
+      // [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN
+      // [cfe] Expected ':' before this.
+      //               ^
+      // [analyzer] SYNTACTIC_ERROR.EXPECTED_TOKEN
+      // [cfe] Expected ';' after this.
+      //                ^
+      // [analyzer] SYNTACTIC_ERROR.MISSING_IDENTIFIER
+      // [analyzer] SYNTACTIC_ERROR.UNEXPECTED_TOKEN
+      // [cfe] Expected an identifier, but got ':'.
+      // [cfe] Unexpected token ':'.
+      case assert(false): // Error
+      //   ^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.UNDEFINED_IDENTIFIER
+      //   ^^^^^^^^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] `assert` can't be used as an expression.
+      case switch (o) { _ => true }: // Error
+      //   ^^^^^^^^^^^^^^^^^^^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] Not a constant expression.
+      //           ^
+      // [cfe] Not a constant expression.
+      case await 0: // Error
+//         ^^^^^^^
+// [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+// [cfe] Not a constant expression.
+      case !false: // Error
+      //   ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_UNARY
+      // [cfe] The unary operator ! is not supported as a constant pattern.
+      case ~0: // Error
+      //   ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_UNARY
+      // [cfe] The unary operator ~ is not supported as a constant pattern.
+      case ++variable: // Error
+      //   ^^^^^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      //     ^^^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] Not a constant expression.
+      case const Class(): // Ok
+      case const Class(0): // Ok
+      case const GenericClass(): // Ok
+      case const GenericClass(a: 0): // Ok
+      case const GenericClass<int>(): // Ok
+      case const GenericClass<int>(a: 0): // Ok
+      case const GenericClass<int>.new(): // Ok
+      case const GenericClass<int>.new(a: 1): // Ok
+      case const []: // Ok
+      case const <int>[]: // Ok
+      case const {}: // Ok
+      case const <int, String>{}: // Ok
+      case const const Class(): // Error
+      //         ^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+      // [cfe] Duplicate 'const' keyword in constant expression.
+      case const const Class(0): // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const const GenericClass(): // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const const GenericClass(a: 0): // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const const GenericClass<int>(): // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const const GenericClass<int>(a: 0): // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const const []: // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const const <int>[]: // Error
+      //         ^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+      // [cfe] Duplicate 'const' keyword in constant expression.
+      case const const {}: // Error
+      //         ^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+      // [cfe] Duplicate 'const' keyword in constant expression.
+      case const const <int, String>{}: // Error
+//               ^^^^^
+// [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+// [cfe] Duplicate 'const' keyword in constant expression.
+      case const new Class(): // Error
+//               ^^^^^^^^^^^
+// [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+// [cfe] New expression is not a constant expression.
+//                   ^
+// [cfe] New expression is not a constant expression.
+      case new Class(): // Error
+      //   ^^^^^^^^^^^
+      // [analyzer] COMPILE_TIME_ERROR.CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION
+      // [cfe] New expression is not a constant expression.
+      //       ^
+      // [cfe] New expression is not a constant expression.
+      case const (): // Error
+      //          ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_EMPTY_RECORD_LITERAL
+      // [cfe] The empty record literal is not supported as a constant pattern.
+      case const const (): // Error
+      //         ^^^^^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_DUPLICATE_CONST
+      // [cfe] Duplicate 'const' keyword in constant expression.
+      case const (1): // Ok
+      case const (-1): // Ok
+      case const (value): // Ok
+      case const (-value): // Ok
+      case const (1 + 2): // Ok
+      case GenericClass<int>: // Error
+      //               ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_GENERIC
+      // [cfe] This expression is not supported as a constant pattern.
+      case prefix.GenericClass<int>: // Error
+      //                      ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_GENERIC
+      // [cfe] This expression is not supported as a constant pattern.
+      case GenericClass<int>.new: // Error
+      //               ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_GENERIC
+      // [cfe] This expression is not supported as a constant pattern.
+      case prefix.GenericClass<int>.new: // Error
+      //                      ^
+      // [analyzer] SYNTACTIC_ERROR.INVALID_CONSTANT_PATTERN_GENERIC
+      // [cfe] This expression is not supported as a constant pattern.
+      case const (GenericClass<int>): // Ok
+      case const (prefix.GenericClass<int>): // Ok
+      case const (GenericClass<int>.new): // Ok
+      case const (prefix.GenericClass<int>.new): // Ok
+       print(0);
+    }
+  }
+}
+
+class GenericClass<T> {
+  const GenericClass({a});
+}

tools/VERSION

diff --git a/tools/VERSION b/tools/VERSION
index 26d2fbf..abcc0a4 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 3
 MINOR 0
 PATCH 0
-PRERELEASE 220
+PRERELEASE 221
 PRERELEASE_PATCH 0